diff --git a/.github/workflows/build_deploy_dev.yml b/.github/workflows/build_deploy_dev.yml
index 78701c7b6da..cc9d25f7edd 100644
--- a/.github/workflows/build_deploy_dev.yml
+++ b/.github/workflows/build_deploy_dev.yml
@@ -77,6 +77,18 @@ jobs:
           platforms: linux/amd64
           push-cache: false
 
+  scan-keycloak:
+    runs-on: mdb-dev
+    needs: [ build ]
+    name: Scan cloud-cpu image
+    steps:
+      - uses: actions/checkout@v4
+      - uses: mindsdb/github-actions/snyk-docker-scan@main
+        with:
+          image: 168681354662.dkr.ecr.us-east-1.amazonaws.com/mindsdb:${{ github.event.pull_request.head.sha }}-cloud-cpu
+          snyk-token: ${{ secrets.SNYK_TOKEN }}
+          dockerfile: docker/mindsdb.Dockerfile
+
   # Push cache layers to docker registry
   # This is separate to the build step so we can do other stuff in parallel
   build-cache:
diff --git a/.github/workflows/tests_unit.yml b/.github/workflows/tests_unit.yml
index 3a9455a7f76..eb8905a520e 100644
--- a/.github/workflows/tests_unit.yml
+++ b/.github/workflows/tests_unit.yml
@@ -32,8 +32,9 @@ env:
     github
     ms_teams
     statsforecast
-    chromadb
+    duckdb_faiss
     confluence
+    openai
   # We measure 80% on this handlers, as they are the verified
   HANDLERS_TO_VERIFY: |
     mysql
@@ -163,8 +164,6 @@ jobs:
           uv pip install ".[agents,kb]" \
             -r requirements/requirements-test.txt \
             "${HANDLER_EXTRAS[@]}"
-          # Onuxruntime is required for ChromaDB, once we have default pgvector we can remove it
-          uv pip install --force-reinstall onnxruntime==1.20.1
           git clone --branch v$(uv pip show mindsdb_sql_parser | grep Version | cut -d ' ' -f 2) https://github.com/mindsdb/mindsdb_sql_parser.git parser_tests
           
       - name: Run unit tests
diff --git a/Makefile b/Makefile
index 05cea89b906..26d90872dc5 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-PYTEST_ARGS = -v -rs --disable-warnings -n auto --dist loadfile
+PYTEST_ARGS = -v -xrs --disable-warnings -n 1 --dist loadfile
 PYTEST_ARGS_DEBUG = --runslow -vs -rs
 DSI_PYTEST_ARGS = --run-dsi-tests
 DSI_REPORT_ARGS = --json-report --json-report-file=reports/report.json
diff --git a/assets/contributions-agreement/signatures/cla.json b/assets/contributions-agreement/signatures/cla.json
index dc0e2328551..b3dabe85607 100644
--- a/assets/contributions-agreement/signatures/cla.json
+++ b/assets/contributions-agreement/signatures/cla.json
@@ -5831,6 +5831,1054 @@
       "created_at": "2023-10-30T12:46:04Z",
       "repoId": 143328315,
       "pullRequestNo": 8163
+    },
+    {
+      "name": "minakshisharma197",
+      "id": 184736207,
+      "comment_id": 2413433683,
+      "created_at": "2024-10-15T09:55:40Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9865
+    },
+    {
+      "name": "divyakhatiyan",
+      "id": 141419850,
+      "comment_id": 2417330560,
+      "created_at": "2024-10-16T16:28:34Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9899
+    },
+    {
+      "name": "Sekhar-Kumar-Dash",
+      "id": 119131588,
+      "comment_id": 2419495274,
+      "created_at": "2024-10-17T13:05:15Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9914
+    },
+    {
+      "name": "kom-senapati",
+      "id": 92045934,
+      "comment_id": 2423485137,
+      "created_at": "2024-10-19T02:28:49Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9807
+    },
+    {
+      "name": "RiyanaD",
+      "id": 117534139,
+      "comment_id": 2420766574,
+      "created_at": "2024-10-17T22:54:53Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9427
+    },
+    {
+      "name": "narengogi",
+      "id": 47327611,
+      "comment_id": 2296396377,
+      "created_at": "2024-08-19T11:55:54Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9641
+    },
+    {
+      "name": "PatLittle",
+      "id": 31454591,
+      "comment_id": 2425743649,
+      "created_at": "2024-10-21T06:49:47Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9962
+    },
+    {
+      "name": "panoskyriakis",
+      "id": 134383572,
+      "comment_id": 2317914456,
+      "created_at": "2024-08-29T14:39:56Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9654
+    },
+    {
+      "name": "lucas-koontz",
+      "id": 7515210,
+      "comment_id": 2428585608,
+      "created_at": "2024-10-22T08:19:54Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9976
+    },
+    {
+      "name": "Tryxns",
+      "id": 10586708,
+      "comment_id": 2433530462,
+      "created_at": "2024-10-23T21:51:00Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9975
+    },
+    {
+      "name": "DhanushNehru",
+      "id": 22955675,
+      "comment_id": 2438155935,
+      "created_at": "2024-10-25T15:40:09Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10047
+    },
+    {
+      "name": "TalaatHasanin",
+      "id": 105648065,
+      "comment_id": 2439488990,
+      "created_at": "2024-10-26T10:54:04Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9726
+    },
+    {
+      "name": "AkashJana18",
+      "id": 103350981,
+      "comment_id": 2442254462,
+      "created_at": "2024-10-28T17:52:47Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10073
+    },
+    {
+      "name": "prajwal-pai77",
+      "id": 108796209,
+      "comment_id": 2445980761,
+      "created_at": "2024-10-30T06:33:47Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10039
+    },
+    {
+      "name": "JanumalaAkhilendra",
+      "id": 82641474,
+      "comment_id": 2446791257,
+      "created_at": "2024-10-30T11:43:16Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10051
+    },
+    {
+      "name": "herjanice",
+      "id": 72483795,
+      "comment_id": 2370891577,
+      "created_at": "2024-09-24T10:33:26Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9727
+    },
+    {
+      "name": "mabderrahim",
+      "id": 20402768,
+      "comment_id": 2377340466,
+      "created_at": "2024-09-26T15:48:00Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9727
+    },
+    {
+      "name": "mohamed-abderrahim3",
+      "id": 183199390,
+      "comment_id": 2380593605,
+      "created_at": "2024-09-28T10:19:38Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9727
+    },
+    {
+      "name": "chuangyeshuo",
+      "id": 14370480,
+      "comment_id": 2449017804,
+      "created_at": "2024-10-31T05:05:38Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10099
+    },
+    {
+      "name": "md-abid-hussain",
+      "id": 101964499,
+      "comment_id": 2449303679,
+      "created_at": "2024-10-31T08:26:54Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10100
+    },
+    {
+      "name": "poisonvine",
+      "id": 179939949,
+      "comment_id": 2408223847,
+      "created_at": "2024-10-11T23:08:39Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9833
+    },
+    {
+      "name": "code-vine",
+      "id": 95056519,
+      "comment_id": 2408235943,
+      "created_at": "2024-10-11T23:31:03Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9833
+    },
+    {
+      "name": "poisonvine",
+      "id": 179939949,
+      "comment_id": 2463687190,
+      "created_at": "2024-11-08T03:30:34Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9833
+    },
+    {
+      "name": "vishwamartur",
+      "id": 64204611,
+      "comment_id": 2480506920,
+      "created_at": "2024-11-16T10:24:05Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10176
+    },
+    {
+      "name": "UTSAVS26",
+      "id": 119779889,
+      "comment_id": 2482548112,
+      "created_at": "2024-11-18T10:15:35Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10182
+    },
+    {
+      "name": "fshabashev",
+      "id": 6548211,
+      "comment_id": 2482924022,
+      "created_at": "2024-11-18T12:36:59Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10153
+    },
+    {
+      "name": "GTgyani206",
+      "id": 128274569,
+      "comment_id": 2407637789,
+      "created_at": "2024-10-11T15:20:07Z",
+      "repoId": 143328315,
+      "pullRequestNo": 9832
+    },
+    {
+      "name": "QuantumPlumber",
+      "id": 44450703,
+      "comment_id": 2521508302,
+      "created_at": "2024-12-05T21:39:15Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10243
+    },
+    {
+      "name": "Abdusshh",
+      "id": 101020733,
+      "comment_id": 2525127867,
+      "created_at": "2024-12-07T13:40:48Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10253
+    },
+    {
+      "name": "cliffordp",
+      "id": 1812179,
+      "comment_id": 2540449382,
+      "created_at": "2024-12-13T03:21:48Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10285
+    },
+    {
+      "name": "abhirajadhikary06",
+      "id": 171187625,
+      "comment_id": 2563775672,
+      "created_at": "2024-12-27T14:55:52Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10331
+    },
+    {
+      "name": "jbrass",
+      "id": 125982,
+      "comment_id": 2587312474,
+      "created_at": "2025-01-13T14:50:21Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10355
+    },
+    {
+      "name": "dj013",
+      "id": 47425755,
+      "comment_id": 2593267189,
+      "created_at": "2025-01-15T15:43:10Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10371
+    },
+    {
+      "name": "juliette0704",
+      "id": 91728573,
+      "comment_id": 2609377887,
+      "created_at": "2025-01-23T10:01:31Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10395
+    },
+    {
+      "name": "ivancastanop",
+      "id": 107499323,
+      "comment_id": 2598203208,
+      "created_at": "2025-01-17T11:55:12Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10379
+    },
+    {
+      "name": "rdonato",
+      "id": 128521,
+      "comment_id": 2643683251,
+      "created_at": "2025-02-07T18:22:51Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10444
+    },
+    {
+      "name": "SoNiC-HeRE",
+      "id": 96797205,
+      "comment_id": 2654003700,
+      "created_at": "2025-02-12T15:10:05Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10460
+    },
+    {
+      "name": "guspan-tanadi",
+      "id": 36249910,
+      "comment_id": 2675814807,
+      "created_at": "2025-02-21T23:28:45Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10465
+    },
+    {
+      "name": "arashaomrani",
+      "id": 20032520,
+      "comment_id": 2705110135,
+      "created_at": "2025-03-06T22:46:52Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10544
+    },
+    {
+      "name": "kevinrawal",
+      "id": 84058124,
+      "comment_id": 2708288010,
+      "created_at": "2025-03-08T13:33:56Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10550
+    },
+    {
+      "name": "MR901",
+      "id": 20877166,
+      "comment_id": 2788354723,
+      "created_at": "2025-04-09T05:54:32Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10681
+    },
+    {
+      "name": "pnewsam",
+      "id": 22651415,
+      "comment_id": 2813745881,
+      "created_at": "2025-04-17T18:35:55Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10736
+    },
+    {
+      "name": "emmanuel-ferdman",
+      "id": 35470921,
+      "comment_id": 2816053850,
+      "created_at": "2025-04-18T19:17:39Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10739
+    },
+    {
+      "name": "Konstantinos-10",
+      "id": 161840728,
+      "comment_id": 2833463268,
+      "created_at": "2025-04-27T13:35:09Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10761
+    },
+    {
+      "name": "NikosLaspias",
+      "id": 148558723,
+      "comment_id": 2834255670,
+      "created_at": "2025-04-28T07:38:11Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10760
+    },
+    {
+      "name": "jzs1997",
+      "id": 29564670,
+      "comment_id": 2840686847,
+      "created_at": "2025-04-30T03:07:12Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10776
+    },
+    {
+      "name": "HarshaVardhanMannem",
+      "id": 144146034,
+      "comment_id": 2896453670,
+      "created_at": "2025-05-21T03:28:49Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10861
+    },
+    {
+      "name": "arun-prasath2005",
+      "id": 84761066,
+      "comment_id": 2906488930,
+      "created_at": "2025-05-24T06:10:22Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10882
+    },
+    {
+      "name": "vmanikanta07",
+      "id": 117996904,
+      "comment_id": 2906811274,
+      "created_at": "2025-05-24T12:37:42Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10885
+    },
+    {
+      "name": "omerc7",
+      "id": 32813109,
+      "comment_id": 2908711653,
+      "created_at": "2025-05-26T06:34:46Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10895
+    },
+    {
+      "name": "trickster026",
+      "id": 212937700,
+      "comment_id": 2910591816,
+      "created_at": "2025-05-26T20:34:08Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10903
+    },
+    {
+      "name": "ivanvza",
+      "id": 8543825,
+      "comment_id": 2911844022,
+      "created_at": "2025-05-27T09:31:36Z",
+      "repoId": 143328315,
+      "pullRequestNo": 10900
+    },
+    {
+      "name": "Joystonm",
+      "id": 116254639,
+      "comment_id": 2965183033,
+      "created_at": "2025-06-12T05:37:40Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11070
+    },
+    {
+      "name": "noname4life",
+      "id": 77653287,
+      "comment_id": 2983573198,
+      "created_at": "2025-06-18T10:07:09Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11117
+    },
+    {
+      "name": "D1m7asis",
+      "id": 80602676,
+      "comment_id": 2985345244,
+      "created_at": "2025-06-18T18:42:15Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11124
+    },
+    {
+      "name": "Alex-xd",
+      "id": 11256006,
+      "comment_id": 2999207900,
+      "created_at": "2025-06-24T07:50:23Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11160
+    },
+    {
+      "name": "PriyanshuPz",
+      "id": 112266318,
+      "comment_id": 3000590454,
+      "created_at": "2025-06-24T13:51:44Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11163
+    },
+    {
+      "name": "rawathemant246",
+      "id": 99639231,
+      "comment_id": 2999067598,
+      "created_at": "2025-06-24T06:59:35Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11159
+    },
+    {
+      "name": "aryanmalik-iet",
+      "id": 187411120,
+      "comment_id": 3007270696,
+      "created_at": "2025-06-26T06:24:35Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11186
+    },
+    {
+      "name": "iabhi4",
+      "id": 61010675,
+      "comment_id": 3017197726,
+      "created_at": "2025-06-29T22:22:14Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11212
+    },
+    {
+      "name": "dotWee",
+      "id": 8060356,
+      "comment_id": 3072932250,
+      "created_at": "2025-07-15T09:45:05Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11300
+    },
+    {
+      "name": "buallen",
+      "id": 54055907,
+      "comment_id": 3078683990,
+      "created_at": "2025-07-16T13:40:32Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11234
+    },
+    {
+      "name": "Raahim-Lone",
+      "id": 175012415,
+      "comment_id": 3120439531,
+      "created_at": "2025-07-25T21:35:44Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11365
+    },
+    {
+      "name": "kaizenjinco",
+      "id": 78314961,
+      "comment_id": 3124537097,
+      "created_at": "2025-07-27T16:53:30Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11367
+    },
+    {
+      "name": "huang-x-h",
+      "id": 381860,
+      "comment_id": 3132498852,
+      "created_at": "2025-07-29T13:16:29Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11126
+    },
+    {
+      "name": "aperepel",
+      "id": 119367,
+      "comment_id": 3137657308,
+      "created_at": "2025-07-30T20:03:35Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11385
+    },
+    {
+      "name": "abhayasr",
+      "id": 108477628,
+      "comment_id": 3164476409,
+      "created_at": "2025-08-07T14:39:49Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11291
+    },
+    {
+      "name": "logan-mo",
+      "id": 63550599,
+      "comment_id": 3167373652,
+      "created_at": "2025-08-08T10:27:53Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11414
+    },
+    {
+      "name": "kylediaz",
+      "id": 35979917,
+      "comment_id": 3180690963,
+      "created_at": "2025-08-12T19:21:02Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11427
+    },
+    {
+      "name": "Kenxpx",
+      "id": 155082290,
+      "comment_id": 3194287003,
+      "created_at": "2025-08-17T10:15:06Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11450
+    },
+    {
+      "name": "Nancy9ice",
+      "id": 103530451,
+      "comment_id": 3197557060,
+      "created_at": "2025-08-18T16:11:20Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11453
+    },
+    {
+      "name": "Matvey-Kuk",
+      "id": 3284841,
+      "comment_id": 3197947416,
+      "created_at": "2025-08-18T18:18:26Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11452
+    },
+    {
+      "name": "louisneal",
+      "id": 47094728,
+      "comment_id": 3222541351,
+      "created_at": "2025-08-26T04:06:55Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11478
+    },
+    {
+      "name": "sejubar",
+      "id": 154475559,
+      "comment_id": 3240009269,
+      "created_at": "2025-08-31T09:59:19Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11495
+    },
+    {
+      "name": "sudsmenon",
+      "id": 11342520,
+      "comment_id": 3250743797,
+      "created_at": "2025-09-03T20:48:18Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11510
+    },
+    {
+      "name": "TaniyaKatigar",
+      "id": 214086943,
+      "comment_id": 3262560837,
+      "created_at": "2025-09-06T16:30:40Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11530
+    },
+    {
+      "name": "GeorgeGithiri5",
+      "id": 46107866,
+      "comment_id": 3269367783,
+      "created_at": "2025-09-09T07:49:06Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11541
+    },
+    {
+      "name": "gauiPPP",
+      "id": 43440362,
+      "comment_id": 3284159007,
+      "created_at": "2025-09-12T07:46:21Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11554
+    },
+    {
+      "name": "morningman",
+      "id": 2899462,
+      "comment_id": 3293544413,
+      "created_at": "2025-09-15T19:07:52Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11574
+    },
+    {
+      "name": "sadiqkhzn",
+      "id": 24961132,
+      "comment_id": 3312201690,
+      "created_at": "2025-09-19T13:26:49Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11596
+    },
+    {
+      "name": "yumosx",
+      "id": 141902143,
+      "comment_id": 3322908961,
+      "created_at": "2025-09-23T08:21:07Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11605
+    },
+    {
+      "name": "aimurphy",
+      "id": 36110273,
+      "comment_id": 3335211124,
+      "created_at": "2025-09-25T17:38:00Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11618
+    },
+    {
+      "name": "richardokonicha",
+      "id": 48168290,
+      "comment_id": 3346750889,
+      "created_at": "2025-09-29T12:48:00Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11552
+    },
+    {
+      "name": "vigbav36",
+      "id": 90998381,
+      "comment_id": 3361788337,
+      "created_at": "2025-10-02T15:24:35Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11666
+    },
+    {
+      "name": "yashisthebatman",
+      "id": 149709821,
+      "comment_id": 3364470461,
+      "created_at": "2025-10-03T06:48:03Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11676
+    },
+    {
+      "name": "survivant",
+      "id": 191879,
+      "comment_id": 3369115643,
+      "created_at": "2025-10-05T15:02:15Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11684
+    },
+    {
+      "name": "Sai-Sravya-Thumati",
+      "id": 64857617,
+      "comment_id": 3370705793,
+      "created_at": "2025-10-06T09:31:16Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11686
+    },
+    {
+      "name": "cclauss",
+      "id": 3709715,
+      "comment_id": 3364277206,
+      "created_at": "2025-10-03T05:08:38Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11673
+    },
+    {
+      "name": "ParasNingune",
+      "id": 153178176,
+      "comment_id": 3388187853,
+      "created_at": "2025-10-10T03:48:32Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11703
+    },
+    {
+      "name": "HarshitR2004",
+      "id": 159914116,
+      "comment_id": 3388359328,
+      "created_at": "2025-10-10T05:37:12Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11704
+    },
+    {
+      "name": "Nirzak",
+      "id": 11460645,
+      "comment_id": 3393522813,
+      "created_at": "2025-10-11T17:20:41Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11726
+    },
+    {
+      "name": "faizan842",
+      "id": 91795555,
+      "comment_id": 3407632893,
+      "created_at": "2025-10-15T17:55:57Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11748
+    },
+    {
+      "name": "AhmadYasser1",
+      "id": 77586860,
+      "comment_id": 3419161297,
+      "created_at": "2025-10-19T02:48:49Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11766
+    },
+    {
+      "name": "Nikhil172913832",
+      "id": 140622713,
+      "comment_id": 3443931056,
+      "created_at": "2025-10-24T16:13:14Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11786
+    },
+    {
+      "name": "jiaqicheng1998",
+      "id": 65794980,
+      "comment_id": 3459506446,
+      "created_at": "2025-10-29T03:48:36Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11793
+    },
+    {
+      "name": "Aashish079",
+      "id": 106550372,
+      "comment_id": 3461223031,
+      "created_at": "2025-10-29T12:19:16Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11812
+    },
+    {
+      "name": "guddu-debasis",
+      "id": 167549811,
+      "comment_id": 3463419567,
+      "created_at": "2025-10-29T19:15:44Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11821
+    },
+    {
+      "name": "jeis4wpi",
+      "id": 42679190,
+      "comment_id": 3467642515,
+      "created_at": "2025-10-30T11:55:54Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11822
+    },
+    {
+      "name": "ak4shravikumar",
+      "id": 189372043,
+      "comment_id": 3469119609,
+      "created_at": "2025-10-30T17:15:30Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11828
+    },
+    {
+      "name": "rajesh-adk-137",
+      "id": 89499267,
+      "comment_id": 3470873094,
+      "created_at": "2025-10-31T00:51:14Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11835
+    },
+    {
+      "name": "KrishThakur23",
+      "id": 214495511,
+      "comment_id": 3475330781,
+      "created_at": "2025-11-01T01:05:56Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11841
+    },
+    {
+      "name": "ritoban23",
+      "id": 124308320,
+      "comment_id": 3476917215,
+      "created_at": "2025-11-01T22:16:42Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11843
+    },
+    {
+      "name": "bala-ceg",
+      "id": 70808619,
+      "comment_id": 3478836423,
+      "created_at": "2025-11-03T04:05:40Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11844
+    },
+    {
+      "name": "HamoonDBA",
+      "id": 3939424,
+      "comment_id": 3499521731,
+      "created_at": "2025-11-06T21:49:51Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11858
+    },
+    {
+      "name": "md-ziauddin",
+      "id": 29926473,
+      "comment_id": 3533762471,
+      "created_at": "2025-11-14T17:15:19Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11888
+    },
+    {
+      "name": "suman-X",
+      "id": 137594910,
+      "comment_id": 3534136586,
+      "created_at": "2025-11-14T18:54:22Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11890
+    },
+    {
+      "name": "suman-X",
+      "id": 137594910,
+      "comment_id": 3534230691,
+      "created_at": "2025-11-14T19:21:59Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11890
+    },
+    {
+      "name": "SyedaAnshrahGillani",
+      "id": 90501474,
+      "comment_id": 3616952272,
+      "created_at": "2025-12-05T13:33:42Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11973
+    },
+    {
+      "name": "neversettle17-101",
+      "id": 41864816,
+      "comment_id": 3620426556,
+      "created_at": "2025-12-06T13:56:57Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11975
+    },
+    {
+      "name": "duskobogdanovski",
+      "id": 21080468,
+      "comment_id": 3656079267,
+      "created_at": "2025-12-15T14:55:07Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12013
+    },
+    {
+      "name": "kelvinvelasquez-SDE",
+      "id": 112011775,
+      "comment_id": 3675658408,
+      "created_at": "2025-12-19T16:19:32Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12029
+    },
+    {
+      "name": "PPeitsch",
+      "id": 88450637,
+      "comment_id": 3704693294,
+      "created_at": "2026-01-02T07:50:33Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12048
+    },
+    {
+      "name": "SachinMyadam",
+      "id": 110909093,
+      "comment_id": 3716118688,
+      "created_at": "2026-01-06T20:02:10Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12054
+    },
+    {
+      "name": "xuwei95",
+      "id": 18109811,
+      "comment_id": 3723114411,
+      "created_at": "2026-01-08T10:01:14Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12063
+    },
+    {
+      "name": "Nandha-kumar-S",
+      "id": 85221220,
+      "comment_id": 3727602927,
+      "created_at": "2026-01-09T07:52:10Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12082
+    },
+    {
+      "name": "Sweetdevil144",
+      "id": 117591942,
+      "comment_id": 3761427133,
+      "created_at": "2026-01-16T19:12:39Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12110
+    },
+    {
+      "name": "Sriram-B-Srivatsa",
+      "id": 144884365,
+      "comment_id": 3765374596,
+      "created_at": "2026-01-18T14:51:54Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12113
+    },
+    {
+      "name": "zhaojinxin409",
+      "id": 5874804,
+      "comment_id": 3771260955,
+      "created_at": "2026-01-20T06:34:45Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12122
+    },
+    {
+      "name": "murataslan1",
+      "id": 78961478,
+      "comment_id": 3784602307,
+      "created_at": "2026-01-22T14:06:33Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12004
+    },
+    {
+      "name": "C1ARKGABLE",
+      "id": 13039858,
+      "comment_id": 3792661007,
+      "created_at": "2026-01-23T21:53:19Z",
+      "repoId": 143328315,
+      "pullRequestNo": 11988
+    },
+    {
+      "name": "AndrewFarley",
+      "id": 470163,
+      "comment_id": 3801391357,
+      "created_at": "2026-01-26T19:40:00Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12123
+    },
+    {
+      "name": "007slm",
+      "id": 1670036,
+      "comment_id": 3803635367,
+      "created_at": "2026-01-27T07:48:21Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12155
+    },
+    {
+      "name": "C0staTin",
+      "id": 12409467,
+      "comment_id": 3812795861,
+      "created_at": "2026-01-28T17:36:00Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12151
+    },
+    {
+      "name": "Amogh-2404",
+      "id": 114862749,
+      "comment_id": 3814926744,
+      "created_at": "2026-01-29T02:00:24Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12167
+    },
+    {
+      "name": "themavik",
+      "id": 179817126,
+      "comment_id": 3936291923,
+      "created_at": "2026-02-20T17:50:39Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12213
+    },
+    {
+      "name": "ianu82",
+      "id": 86010258,
+      "comment_id": 3973995110,
+      "created_at": "2026-02-27T16:55:27Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12251
+    },
+    {
+      "name": "Mirza-Samad-Ahmed-Baig",
+      "id": 89132160,
+      "comment_id": 4054729064,
+      "created_at": "2026-03-13T12:24:17Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12290
+    },
+    {
+      "name": "Krishnav1237",
+      "id": 147693159,
+      "comment_id": 4061239564,
+      "created_at": "2026-03-14T19:45:50Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12294
+    },
+    {
+      "name": "StefanTrsunov",
+      "id": 91495981,
+      "comment_id": 4070493719,
+      "created_at": "2026-03-16T20:45:48Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12297
+    },
+    {
+      "name": "Tzsapphire",
+      "id": 209363831,
+      "comment_id": 4106737895,
+      "created_at": "2026-03-22T18:27:23Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12317
+    },
+    {
+      "name": "jnMetaCode",
+      "id": 12096460,
+      "comment_id": 4111619407,
+      "created_at": "2026-03-23T15:43:15Z",
+      "repoId": 143328315,
+      "pullRequestNo": 12279
     }
   ]
 }
\ No newline at end of file
diff --git a/docker/docker-bake.hcl b/docker/docker-bake.hcl
index d7ad61ed0c8..5e12da05fbb 100644
--- a/docker/docker-bake.hcl
+++ b/docker/docker-bake.hcl
@@ -105,23 +105,23 @@ target "images" {
     item = [
       {
         name = "bare"
-        extras = ".[agents,kb,mysql,postgresql,snowflake,bigquery,mssql,mssql-odbc,salesforce,duckdb_faiss]"
+        extras = ".[agents,kb,mysql,postgresql,snowflake,bigquery,mssql,mssql-odbc,salesforce,duckdb_faiss,pgvector]"
         target = ""
       },
       {
         name = "devel"
-        extras = ".[agents,kb,mysql,postgresql,snowflake,bigquery,mssql,mssql-odbc,salesforce,duckdb_faiss]"  # Required for running integration tests
+        extras = ".[agents,kb,mysql,postgresql,snowflake,bigquery,mssql,mssql-odbc,salesforce,duckdb_faiss,pgvector]"  # Required for running integration tests
         target = "dev"
       },
       {
         # If you make any changes here, make them to cloud-cpu as well
         name = "cloud"
-        extras = ".[mysql,statsforecast-extra,neuralforecast-extra,timegpt,mssql,mssql-odbc,gmail,snowflake,clickhouse,bigquery,elasticsearch,s3,databricks,oracle,opentelemetry,langfuse,jira,salesforce,gong,hubspot,netsuite,shopify,agents,kb] darts datasetsforecast transformers"
+        extras = ".[mysql,statsforecast-extra,neuralforecast-extra,timegpt,mssql,mssql-odbc,gmail,snowflake,clickhouse,bigquery,elasticsearch,s3,databricks,oracle,opentelemetry,langfuse,jira,salesforce,gong,hubspot,netsuite,shopify,agents,kb,pgvector] darts datasetsforecast transformers"
         target = ""
       },
       {
         name = "cloud-cpu"
-        extras = ".[mysql,statsforecast-extra,neuralforecast-extra,timegpt,mssql,mssql-odbc,gmail,snowflake,clickhouse,bigquery,elasticsearch,s3,databricks,oracle,opentelemetry,langfuse,jira,salesforce,gong,hubspot,netsuite,shopify,agents,kb] darts datasetsforecast transformers"
+        extras = ".[mysql,statsforecast-extra,neuralforecast-extra,timegpt,mssql,mssql-odbc,gmail,snowflake,clickhouse,bigquery,elasticsearch,s3,databricks,oracle,opentelemetry,langfuse,jira,salesforce,gong,hubspot,netsuite,shopify,agents,kb,pgvector] darts datasetsforecast transformers"
         target = ""
       },
     ]
diff --git a/docker/mindsdb.Dockerfile b/docker/mindsdb.Dockerfile
index 2712c854daf..bf482b50e6f 100644
--- a/docker/mindsdb.Dockerfile
+++ b/docker/mindsdb.Dockerfile
@@ -1,7 +1,7 @@
 # This stage's objective is to gather ONLY requirements.txt files and anything else needed to install deps.
 # This stage will be run almost every build, but it is fast and the resulting layer hash will be the same unless a deps file changes.
 # We do it this way because we can't copy all requirements files with a glob pattern in docker while maintaining the folder structure.
-FROM python:3.10 AS deps
+FROM python:3.10.20 AS deps
 WORKDIR /mindsdb
 
 # Copy everything to begin with
@@ -18,10 +18,8 @@ COPY mindsdb/__about__.py mindsdb/
 # Which will mean the next stage can be cached, even if the cache for the above stage was invalidated.
 
 
-
-
 # Use the stage from above to install our deps with as much caching as possible
-FROM python:3.10 AS build
+FROM python:3.10.20 AS build
 WORKDIR /mindsdb
 
 # Configure apt to retain downloaded packages so we can store them in a cache mount
@@ -56,7 +54,7 @@ COPY --from=deps /mindsdb .
 # - and finally declare `/mindsdb` as the target dir.
 ENV UV_LINK_MODE=copy \
     UV_PYTHON_DOWNLOADS=never \
-    UV_PYTHON=python3.10 \
+    UV_PYTHON=python3.10.20 \
     UV_PROJECT_ENVIRONMENT=/mindsdb \
     VIRTUAL_ENV=/venv \
     PATH=/venv/bin:$PATH
@@ -71,6 +69,13 @@ RUN --mount=type=cache,target=/root/.cache \
 
 
 FROM build AS extras
+
+# Apply latest security patches so the final image picks up fixes
+# even when the build stage layers are cached
+RUN --mount=target=/var/lib/apt,type=cache,sharing=locked \
+    --mount=target=/var/cache/apt,type=cache,sharing=locked \
+    apt-get update -qy && apt-get upgrade -qy
+
 ARG EXTRAS
 # Install extras on top of the bare mindsdb
 # The torch index is provided for "-cpu" images which install the cpu-only version of torch
@@ -93,8 +98,10 @@ ENV PATH=/venv/bin:$PATH
 EXPOSE 47334/tcp
 EXPOSE 47335/tcp
 
-# Pre-load tokenizer from Huggingface, and UI
-RUN python -m mindsdb --config=/root/mindsdb_config.json --load-tokenizer --update-gui
+HEALTHCHECK --interval=30s --timeout=10s --retries=5 --start-period=60s CMD curl -fsS "http://localhost:47334/api/status"
+
+# Pre-load web GUI
+RUN python -m mindsdb --config=/root/mindsdb_config.json --update-gui
 
 # Same as extras image, but with dev dependencies installed.
 # This image is used in our docker-compose
diff --git a/docs/assets/BearHeroImageMindsDB.jpeg b/docs/assets/BearHeroImageMindsDB.jpeg
deleted file mode 100644
index 0e017c94693..00000000000
Binary files a/docs/assets/BearHeroImageMindsDB.jpeg and /dev/null differ
diff --git a/docs/assets/MindsDBLightwood@3x.png b/docs/assets/MindsDBLightwood@3x.png
deleted file mode 100644
index 74c7d8ca2ec..00000000000
Binary files a/docs/assets/MindsDBLightwood@3x.png and /dev/null differ
diff --git a/docs/assets/TWbot - hero Snoopstein.png b/docs/assets/TWbot - hero Snoopstein.png
deleted file mode 100644
index 476c9101759..00000000000
Binary files a/docs/assets/TWbot - hero Snoopstein.png and /dev/null differ
diff --git a/docs/assets/TWbot-response-image.png b/docs/assets/TWbot-response-image.png
deleted file mode 100644
index 179df1ad4ce..00000000000
Binary files a/docs/assets/TWbot-response-image.png and /dev/null differ
diff --git a/docs/assets/TWbot-response1.png b/docs/assets/TWbot-response1.png
deleted file mode 100644
index 8322450a5c5..00000000000
Binary files a/docs/assets/TWbot-response1.png and /dev/null differ
diff --git a/docs/assets/TWbot-response2.png b/docs/assets/TWbot-response2.png
deleted file mode 100644
index ec2ed3f9d1b..00000000000
Binary files a/docs/assets/TWbot-response2.png and /dev/null differ
diff --git a/docs/assets/TWbot-response3.png b/docs/assets/TWbot-response3.png
deleted file mode 100644
index 9e988bb273b..00000000000
Binary files a/docs/assets/TWbot-response3.png and /dev/null differ
diff --git a/docs/assets/TWbot-response4.png b/docs/assets/TWbot-response4.png
deleted file mode 100644
index 21effa5798a..00000000000
Binary files a/docs/assets/TWbot-response4.png and /dev/null differ
diff --git a/docs/assets/TWbot-response5.png b/docs/assets/TWbot-response5.png
deleted file mode 100644
index 6a868c65550..00000000000
Binary files a/docs/assets/TWbot-response5.png and /dev/null differ
diff --git a/docs/assets/a2a-unavailable.png b/docs/assets/a2a-unavailable.png
deleted file mode 100644
index 20ede064b14..00000000000
Binary files a/docs/assets/a2a-unavailable.png and /dev/null differ
diff --git a/docs/assets/agent_diagram.png b/docs/assets/agent_diagram.png
deleted file mode 100644
index 56e7689bada..00000000000
Binary files a/docs/assets/agent_diagram.png and /dev/null differ
diff --git a/docs/assets/ai_system_deployment.png b/docs/assets/ai_system_deployment.png
deleted file mode 100644
index 720384986c1..00000000000
Binary files a/docs/assets/ai_system_deployment.png and /dev/null differ
diff --git a/docs/assets/ai_workflow_automation.png b/docs/assets/ai_workflow_automation.png
deleted file mode 100644
index 72184ecc384..00000000000
Binary files a/docs/assets/ai_workflow_automation.png and /dev/null differ
diff --git a/docs/assets/cloud-login.png b/docs/assets/cloud-login.png
deleted file mode 100644
index 32e39f0437e..00000000000
Binary files a/docs/assets/cloud-login.png and /dev/null differ
diff --git a/docs/assets/cloud-signup.png b/docs/assets/cloud-signup.png
deleted file mode 100644
index 50673620fa0..00000000000
Binary files a/docs/assets/cloud-signup.png and /dev/null differ
diff --git a/docs/assets/cloud/cloud-signup-filledout.png b/docs/assets/cloud/cloud-signup-filledout.png
deleted file mode 100644
index 91175fb2146..00000000000
Binary files a/docs/assets/cloud/cloud-signup-filledout.png and /dev/null differ
diff --git a/docs/assets/cloud/dedicated_instance_off.png b/docs/assets/cloud/dedicated_instance_off.png
deleted file mode 100644
index 25930e0dedc..00000000000
Binary files a/docs/assets/cloud/dedicated_instance_off.png and /dev/null differ
diff --git a/docs/assets/cloud/dedicated_instance_on.png b/docs/assets/cloud/dedicated_instance_on.png
deleted file mode 100644
index 8c3d7dc6751..00000000000
Binary files a/docs/assets/cloud/dedicated_instance_on.png and /dev/null differ
diff --git a/docs/assets/cloud/email.png b/docs/assets/cloud/email.png
deleted file mode 100644
index 781bb2e7b1b..00000000000
Binary files a/docs/assets/cloud/email.png and /dev/null differ
diff --git a/docs/assets/cloud/gui.png b/docs/assets/cloud/gui.png
deleted file mode 100644
index ba3c270db21..00000000000
Binary files a/docs/assets/cloud/gui.png and /dev/null differ
diff --git a/docs/assets/cloud/import_file.png b/docs/assets/cloud/import_file.png
deleted file mode 100644
index 24f0332896e..00000000000
Binary files a/docs/assets/cloud/import_file.png and /dev/null differ
diff --git a/docs/assets/cloud/import_file_2.png b/docs/assets/cloud/import_file_2.png
deleted file mode 100644
index 2219fb87387..00000000000
Binary files a/docs/assets/cloud/import_file_2.png and /dev/null differ
diff --git a/docs/assets/cloud/login.png b/docs/assets/cloud/login.png
deleted file mode 100644
index bdd8c788657..00000000000
Binary files a/docs/assets/cloud/login.png and /dev/null differ
diff --git a/docs/assets/cloud/plan_table.png b/docs/assets/cloud/plan_table.png
deleted file mode 100644
index a5b2db3206c..00000000000
Binary files a/docs/assets/cloud/plan_table.png and /dev/null differ
diff --git a/docs/assets/connect_compass_cloud.png b/docs/assets/connect_compass_cloud.png
deleted file mode 100644
index 7cd7304ac6f..00000000000
Binary files a/docs/assets/connect_compass_cloud.png and /dev/null differ
diff --git a/docs/assets/connect_compass_srv.png b/docs/assets/connect_compass_srv.png
deleted file mode 100644
index f1107f229b6..00000000000
Binary files a/docs/assets/connect_compass_srv.png and /dev/null differ
diff --git a/docs/assets/connect_compassm.png b/docs/assets/connect_compassm.png
deleted file mode 100644
index cb411e0bdde..00000000000
Binary files a/docs/assets/connect_compassm.png and /dev/null differ
diff --git a/docs/assets/connect_mongo_compass.png b/docs/assets/connect_mongo_compass.png
deleted file mode 100644
index 4871a35bd44..00000000000
Binary files a/docs/assets/connect_mongo_compass.png and /dev/null differ
diff --git a/docs/assets/connect_mongo_compass_1.png b/docs/assets/connect_mongo_compass_1.png
deleted file mode 100644
index 4d0bdfd61d0..00000000000
Binary files a/docs/assets/connect_mongo_compass_1.png and /dev/null differ
diff --git a/docs/assets/connect_mongo_compass_2.png b/docs/assets/connect_mongo_compass_2.png
deleted file mode 100644
index 3168594878f..00000000000
Binary files a/docs/assets/connect_mongo_compass_2.png and /dev/null differ
diff --git a/docs/assets/connect_mongo_compass_3.png b/docs/assets/connect_mongo_compass_3.png
deleted file mode 100644
index c2dbd33da42..00000000000
Binary files a/docs/assets/connect_mongo_compass_3.png and /dev/null differ
diff --git a/docs/assets/connect_mongo_shell.png b/docs/assets/connect_mongo_shell.png
deleted file mode 100644
index 3a75a60332e..00000000000
Binary files a/docs/assets/connect_mongo_shell.png and /dev/null differ
diff --git a/docs/assets/connect_mongo_shell_1.png b/docs/assets/connect_mongo_shell_1.png
deleted file mode 100644
index c954afc41eb..00000000000
Binary files a/docs/assets/connect_mongo_shell_1.png and /dev/null differ
diff --git a/docs/assets/connect_mongo_shell_2.png b/docs/assets/connect_mongo_shell_2.png
deleted file mode 100644
index 76908fa0a80..00000000000
Binary files a/docs/assets/connect_mongo_shell_2.png and /dev/null differ
diff --git a/docs/assets/contribute.png b/docs/assets/contribute.png
deleted file mode 100644
index adbceacb572..00000000000
Binary files a/docs/assets/contribute.png and /dev/null differ
diff --git a/docs/assets/data/mssql-select.gif b/docs/assets/data/mssql-select.gif
deleted file mode 100644
index 759755c4983..00000000000
Binary files a/docs/assets/data/mssql-select.gif and /dev/null differ
diff --git a/docs/assets/databases/mdb-mysql.png b/docs/assets/databases/mdb-mysql.png
deleted file mode 100644
index 640138effcf..00000000000
Binary files a/docs/assets/databases/mdb-mysql.png and /dev/null differ
diff --git a/docs/assets/databases/mdb-postgres.png b/docs/assets/databases/mdb-postgres.png
deleted file mode 100644
index 7bf055cb840..00000000000
Binary files a/docs/assets/databases/mdb-postgres.png and /dev/null differ
diff --git a/docs/assets/databases/mongodb/mongo-mdb-code.png b/docs/assets/databases/mongodb/mongo-mdb-code.png
deleted file mode 100644
index a3ec12afc94..00000000000
Binary files a/docs/assets/databases/mongodb/mongo-mdb-code.png and /dev/null differ
diff --git a/docs/assets/databases/mongodb/mongo-mdb-current.png b/docs/assets/databases/mongodb/mongo-mdb-current.png
deleted file mode 100644
index 6910119bb0b..00000000000
Binary files a/docs/assets/databases/mongodb/mongo-mdb-current.png and /dev/null differ
diff --git a/docs/assets/databases/mongodb/mongo-mdb.png b/docs/assets/databases/mongodb/mongo-mdb.png
deleted file mode 100644
index 4d3f6043800..00000000000
Binary files a/docs/assets/databases/mongodb/mongo-mdb.png and /dev/null differ
diff --git a/docs/assets/dbeaver-check-predictor-status.png b/docs/assets/dbeaver-check-predictor-status.png
deleted file mode 100644
index 6904f13dd14..00000000000
Binary files a/docs/assets/dbeaver-check-predictor-status.png and /dev/null differ
diff --git a/docs/assets/dbeaver-configure-cloud-connection.png b/docs/assets/dbeaver-configure-cloud-connection.png
deleted file mode 100644
index 51ad1f2c8b6..00000000000
Binary files a/docs/assets/dbeaver-configure-cloud-connection.png and /dev/null differ
diff --git a/docs/assets/dbeaver-configure-docker-connection.png b/docs/assets/dbeaver-configure-docker-connection.png
deleted file mode 100644
index 434da45f9d0..00000000000
Binary files a/docs/assets/dbeaver-configure-docker-connection.png and /dev/null differ
diff --git a/docs/assets/dbeaver-create-connection.png b/docs/assets/dbeaver-create-connection.png
deleted file mode 100644
index 6d22deca2c8..00000000000
Binary files a/docs/assets/dbeaver-create-connection.png and /dev/null differ
diff --git a/docs/assets/dbeaver-create-database.png b/docs/assets/dbeaver-create-database.png
deleted file mode 100644
index a742e832bad..00000000000
Binary files a/docs/assets/dbeaver-create-database.png and /dev/null differ
diff --git a/docs/assets/dbeaver-create-predictor-simple.png b/docs/assets/dbeaver-create-predictor-simple.png
deleted file mode 100644
index b17cdad392b..00000000000
Binary files a/docs/assets/dbeaver-create-predictor-simple.png and /dev/null differ
diff --git a/docs/assets/dbeaver-create-script.png b/docs/assets/dbeaver-create-script.png
deleted file mode 100644
index ea4f0447bcf..00000000000
Binary files a/docs/assets/dbeaver-create-script.png and /dev/null differ
diff --git a/docs/assets/dbeaver-empty-script.png b/docs/assets/dbeaver-empty-script.png
deleted file mode 100644
index bb984b71c1c..00000000000
Binary files a/docs/assets/dbeaver-empty-script.png and /dev/null differ
diff --git a/docs/assets/dbeaver-home-rentals-prediction-results.png b/docs/assets/dbeaver-home-rentals-prediction-results.png
deleted file mode 100644
index 5c0032063df..00000000000
Binary files a/docs/assets/dbeaver-home-rentals-prediction-results.png and /dev/null differ
diff --git a/docs/assets/dbeaver-home-rentals-prediction.png b/docs/assets/dbeaver-home-rentals-prediction.png
deleted file mode 100644
index 0f7215e9723..00000000000
Binary files a/docs/assets/dbeaver-home-rentals-prediction.png and /dev/null differ
diff --git a/docs/assets/dbeaver-predict-home-rentals.png b/docs/assets/dbeaver-predict-home-rentals.png
deleted file mode 100644
index d4d35eea7b5..00000000000
Binary files a/docs/assets/dbeaver-predict-home-rentals.png and /dev/null differ
diff --git a/docs/assets/dbeaver-preview-data.png b/docs/assets/dbeaver-preview-data.png
deleted file mode 100644
index 31794e39954..00000000000
Binary files a/docs/assets/dbeaver-preview-data.png and /dev/null differ
diff --git a/docs/assets/getting-started.png b/docs/assets/getting-started.png
deleted file mode 100644
index 168ff02e040..00000000000
Binary files a/docs/assets/getting-started.png and /dev/null differ
diff --git a/docs/assets/icons/Cloud.svg b/docs/assets/icons/Cloud.svg
deleted file mode 100644
index 082345353ab..00000000000
--- a/docs/assets/icons/Cloud.svg
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="68px" height="68px" viewBox="0 0 68 68" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    <title>Cloud</title>
-    <g id="Dumpster" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <g id="Cloud">
-            <circle id="Oval-Copy-2" fill="#00B06D" cx="34" cy="34" r="34"></circle>
-            <path d="M47.9999142,50.2499946 C52.9710098,50.2499946 56.9998927,46.2211117 56.9998927,41.2500161 C56.9998927,36.8976553 53.9061501,33.2625626 49.7998824,32.4328221 C50.0882042,31.6805351 50.2499088,30.8578671 50.2499088,30.0000429 C50.2499088,26.2734893 47.2264785,23.250059 43.4999249,23.250059 C42.1147582,23.250059 40.8210525,23.671933 39.7522913,24.3891325 C37.804626,21.0141406 34.1694647,18.7500697 29.9999571,18.7500697 C23.7843194,18.7500697 18.7499839,23.7844053 18.7499839,30.0000429 C18.7499839,30.1898999 18.7569877,30.379757 18.7640601,30.5695453 C14.8265695,31.954712 12,35.709418 12,40.1250188 C12,45.7148492 16.5351454,50.2499946 22.1249759,50.2499946 L47.9999142,50.2499946 Z" id="c" fill="#FFFFFF" fill-rule="nonzero"></path>
-        </g>
-    </g>
-</svg>
\ No newline at end of file
diff --git a/docs/assets/icons/Database.svg b/docs/assets/icons/Database.svg
deleted file mode 100644
index 25326bf3c90..00000000000
--- a/docs/assets/icons/Database.svg
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="68px" height="68px" viewBox="0 0 68 68" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    <title>Database</title>
-    <g id="Dumpster" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <g id="Database">
-            <circle id="Oval-Copy" fill="#00B06D" cx="34" cy="34" r="34"></circle>
-            <path d="M33.7499624,30.0000429 C42.4452771,30.0000429 49.4999249,27.6897609 49.4999249,24.8572177 L49.4999249,21.6429004 C49.4999249,18.8103571 42.4452771,16.5000751 33.7499624,16.5000751 C25.0546478,16.5000751 18,18.8103571 18,21.6429004 L18,24.8572177 C18,27.6897609 25.0546478,30.0000429 33.7499624,30.0000429 Z M33.7499624,41.2500161 C42.4452771,41.2500161 49.4999249,38.9397341 49.4999249,36.1071908 L49.4999249,28.8750456 C46.1160752,31.2053776 39.9228222,32.2902749 33.7499624,32.2902749 C27.5771027,32.2902749 21.383781,31.2053776 18,28.8750456 L18,36.1071908 C18,38.9397341 25.0546478,41.2500161 33.7499624,41.2500161 Z M33.7499624,52.4999893 C42.4452771,52.4999893 49.4999249,50.1897073 49.4999249,47.357164 L49.4999249,40.1250188 C46.1160752,42.4553507 39.9228222,43.5402481 33.7499624,43.5402481 C27.5771027,43.5402481 21.383781,42.4553507 18,40.1250188 L18,47.357164 C18,50.1897073 25.0546478,52.4999893 33.7499624,52.4999893 Z" id="d" fill="#FFFFFF" fill-rule="nonzero"></path>
-        </g>
-    </g>
-</svg>
\ No newline at end of file
diff --git a/docs/assets/icons/Explainable.svg b/docs/assets/icons/Explainable.svg
deleted file mode 100644
index 96514672a8f..00000000000
--- a/docs/assets/icons/Explainable.svg
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="68px" height="68px" viewBox="0 0 68 68" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    <title>Explainable</title>
-    <g id="Dumpster" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <g id="Explainable">
-            <circle id="Oval-Copy-3" fill="#00B06D" cx="34" cy="34" r="34"></circle>
-            <path d="M53.6249008,45.7500054 C55.486049,45.7500054 56.9998927,44.185556 56.9998927,42.2632278 L56.9998927,19.9868527 C56.9998927,18.0645245 55.486049,16.5000751 53.6249008,16.5000751 L26.6249651,16.5000751 C24.7638169,16.5000751 23.2499732,18.0645245 23.2499732,19.9868527 L23.2499732,23.250059 C24.8966825,23.250059 26.4210319,23.7267958 27.7499624,24.5016048 L27.7499624,21.0000644 L52.4999034,21.0000644 L52.4999034,41.2500161 L47.9999142,41.2500161 L47.9999142,36.7500268 L38.9999356,36.7500268 L38.9999356,41.2500161 L33.6393069,41.2500161 C34.9823137,42.4235591 35.9680596,43.9732457 36.4300336,45.7500054 L53.6249008,45.7500054 Z M23.2499732,39.0000215 C26.9779001,39.0000215 29.9999571,35.9779645 29.9999571,32.2500376 C29.9999571,28.5221106 26.9779001,25.5000536 23.2499732,25.5000536 C19.5220463,25.5000536 16.4999893,28.5221106 16.4999893,32.2500376 C16.4999893,35.9779645 19.5220463,39.0000215 23.2499732,39.0000215 Z M31.1249544,52.4999893 C32.9720264,52.4999893 34.4901273,51.0149846 34.50006,49.1685992 C34.5231549,44.7994156 30.9885183,41.2500161 26.6249651,41.2500161 C26.4569434,41.2500161 26.288853,41.2745979 26.1285903,41.3266455 C25.2173452,41.6226577 24.2589277,41.8125148 23.2499732,41.8125148 C22.2410187,41.8125148 21.2826012,41.6226577 20.3706694,41.3266455 C20.2103381,41.2745979 20.043003,41.2500161 19.8749812,41.2500161 C15.5114281,41.2500161 11.9767914,44.7994156 11.9998864,49.1685992 C12.009819,51.0149846 13.5279199,52.4999893 15.374992,52.4999893 L31.1249544,52.4999893 Z" id="c" fill="#FFFFFF" fill-rule="nonzero"></path>
-        </g>
-    </g>
-</svg>
\ No newline at end of file
diff --git a/docs/assets/icons/GUI.svg b/docs/assets/icons/GUI.svg
deleted file mode 100644
index ea99f55e989..00000000000
--- a/docs/assets/icons/GUI.svg
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="68px" height="68px" viewBox="0 0 68 68" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    <title>GUI</title>
-    <g id="Dumpster" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <g id="GUI">
-            <circle id="Oval-Copy-4" fill="#00B06D" cx="34" cy="34" r="34"></circle>
-            <path d="M50.4999225,39.0000238 C50.9998813,39.0000238 51.4999106,38.4999945 51.4999106,38.0000415 L51.4999106,20.0000539 C51.4999106,19.5001009 50.9998813,19.0000715 50.4999225,19.0000715 L47.4999049,19.0000715 C46.9999518,19.0000715 46.4999225,19.5001009 46.4999225,20.0000539 L46.4999225,38.0000415 C46.4999225,38.4999945 46.9999518,39.0000238 47.4999049,39.0000238 L50.4999225,39.0000238 Z M52.7499076,49 C53.4405188,49 53.9999046,48.4406141 53.9999046,47.750003 L53.9999046,45.2500089 C53.9999046,44.5593978 53.4405188,44.0000119 52.7499076,44.0000119 L18.9999881,44.0000119 L18.9999881,20.2500685 C18.9999881,19.5594574 18.4406022,19.0000715 17.7499911,19.0000715 L15.249997,19.0000715 C14.5593859,19.0000715 14,19.5594574 14,20.2500685 L14,46.500006 C14,47.8804653 15.1195347,49 16.5,49 L52.7499076,49 Z M35.4999583,39.0000238 C35.999917,39.0000238 36.4999464,38.4999945 36.4999464,38.0000415 L36.4999464,22.5000479 C36.4999464,22.0000949 35.999917,21.5000656 35.4999583,21.5000656 L32.4999406,21.5000656 C31.9999876,21.5000656 31.4999583,22.0000949 31.4999583,22.5000479 L31.4999583,38.0000415 C31.4999583,38.4999945 31.9999876,39.0000238 32.4999406,39.0000238 L35.4999583,39.0000238 Z M42.9999404,39.0000238 C43.4998991,39.0000238 43.9999285,38.4999945 43.9999285,38.0000415 L43.9999285,27.500036 C43.9999285,27.000083 43.4998991,26.5000536 42.9999404,26.5000536 L39.9999228,26.5000536 C39.4999697,26.5000536 38.9999404,27.000083 38.9999404,27.500036 L38.9999404,38.0000415 C38.9999404,38.4999945 39.4999697,39.0000238 39.9999228,39.0000238 L42.9999404,39.0000238 Z M27.9999762,39.0000238 C28.4999349,39.0000238 28.9999642,38.4999945 28.9999642,38.0000417 L28.9999642,32.5000241 C28.9999642,32.000071 28.4999349,31.5000417 27.9999762,31.5000417 L24.9999585,31.5000417 C24.5000055,31.5000417 23.9999762,32.000071 23.9999762,32.5000241 L23.9999762,38.0000417 C23.9999762,38.4999945 24.5000055,39.0000238 24.9999585,39.0000238 L27.9999762,39.0000238 Z" id="c" fill="#FFFFFF" fill-rule="nonzero"></path>
-        </g>
-    </g>
-</svg>
\ No newline at end of file
diff --git a/docs/assets/icons/Python.svg b/docs/assets/icons/Python.svg
deleted file mode 100644
index 6ac826a7654..00000000000
--- a/docs/assets/icons/Python.svg
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="68px" height="68px" viewBox="0 0 68 68" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    <title>Python</title>
-    <g id="Dumpster" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <g id="Python">
-            <circle id="Oval" fill="#00B06D" cx="34" cy="34" r="34"></circle>
-            <path d="M21.8632577,44.7285163 L21.8632577,39.9629217 C21.8632577,36.5156834 24.8417663,33.478524 28.3866606,33.478524 L38.8163042,33.478524 C41.716707,33.478524 44.0311736,31.0859516 44.0311736,28.1758214 L44.0311736,18.2247304 C44.0311736,15.3927059 41.6483287,13.2735513 38.8163042,12.7949987 C35.3202378,12.2188854 31.521476,12.2481631 28.3866606,12.8048215 C23.9725896,13.5860696 23.1718865,15.2168488 23.1718865,18.2344579 L23.1718865,22.2090769 L33.6112575,22.2090769 L33.6112575,23.5371605 L19.255823,23.5371605 C16.218759,23.5371605 13.5624963,25.3633471 12.7324201,28.8301358 C11.7754102,32.8047547 11.7363097,35.2851603 12.7324201,39.4355411 C13.4745677,42.5215284 15.2421988,44.7285163 18.2792628,44.7285163 L21.8632577,44.7285163 Z M27.7323462,19.5528141 C26.6484026,19.5528141 25.7694984,18.6641825 25.7694984,17.570416 C25.7792259,16.4669221 26.6484026,15.5781951 27.7323462,15.5781951 C28.8065624,15.5781951 29.6952894,16.4766496 29.6952894,17.570416 C29.6952894,18.6641825 28.8163852,19.5528141 27.7323462,19.5528141 Z M39.2948568,55.334017 C41.9218418,54.5722237 44.5097263,53.0391006 44.5097263,50.0312189 L44.5097263,46.0566953 L34.0898102,46.0566953 L34.0898102,44.7285163 L49.7343232,44.7285163 C52.7713872,44.7285163 53.8944314,42.6093616 54.9490973,39.4355411 C56.0428637,36.1640645 55.9940357,33.019617 54.9490973,28.8301358 C54.1971269,25.8125267 52.7713872,23.5371605 49.7343232,23.5371605 L45.8182597,23.5371605 L45.8182597,28.1660939 C45.8182597,31.7598163 42.7713729,34.7871528 39.2948568,34.7871528 L28.8652132,34.7871528 C26.0136385,34.7871528 23.6503438,37.2285532 23.6503438,40.0898555 L23.6503438,50.0312189 C23.6503438,52.8632434 26.1112945,54.5233957 28.8652132,55.334017 C32.1659675,56.3007543 35.3397881,56.4765161 39.2948568,55.334017 Z M39.9491712,52.6777542 C38.874955,52.6777542 37.986228,51.7792998 37.986228,50.6855333 C37.9960508,49.5820394 38.874955,48.7031352 39.9491712,48.7031352 C41.0331148,48.7031352 41.912019,49.5917669 41.912019,50.6855333 C41.912019,51.7890272 41.0331148,52.6777542 39.9491712,52.6777542 Z" id="p" fill="#FFFFFF" fill-rule="nonzero"></path>
-        </g>
-    </g>
-</svg>
\ No newline at end of file
diff --git a/docs/assets/icons/Server.svg b/docs/assets/icons/Server.svg
deleted file mode 100644
index 94f40f4adbd..00000000000
--- a/docs/assets/icons/Server.svg
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="68px" height="68px" viewBox="0 0 68 68" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    <title>Server</title>
-    <g id="Dumpster" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <g id="Server">
-            <circle id="Oval-Copy-5" fill="#00B06D" cx="34" cy="34" r="34"></circle>
-            <path d="M49.7499195,27.7500483 C50.9925389,27.7500483 51.9999142,26.7426731 51.9999142,25.5000536 L51.9999142,21.0000644 C51.9999142,19.757445 50.9925389,18.7500697 49.7499195,18.7500697 L18.2499946,18.7500697 C17.0073752,18.7500697 16,19.757445 16,21.0000644 L16,25.5000536 C16,26.7426731 17.0073752,27.7500483 18.2499946,27.7500483 L49.7499195,27.7500483 Z M46.3749276,24.937555 C45.4429459,24.937555 44.6874316,24.1820407 44.6874316,23.250059 C44.6874316,22.3180773 45.4429459,21.562563 46.3749276,21.562563 C47.3069093,21.562563 48.0624236,22.3180773 48.0624236,23.250059 C48.0624236,24.1820407 47.3069093,24.937555 46.3749276,24.937555 Z M41.8749383,24.937555 C40.9429566,24.937555 40.1874423,24.1820407 40.1874423,23.250059 C40.1874423,22.3180773 40.9429566,21.562563 41.8749383,21.562563 C42.80692,21.562563 43.5624343,22.3180773 43.5624343,23.250059 C43.5624343,24.1820407 42.80692,24.937555 41.8749383,24.937555 Z M49.7499195,39.0000215 C50.9925389,39.0000215 51.9999142,37.9926462 51.9999142,36.7500268 L51.9999142,32.2500376 C51.9999142,31.0074181 50.9925389,30.0000429 49.7499195,30.0000429 L18.2499946,30.0000429 C17.0073752,30.0000429 16,31.0074181 16,32.2500376 L16,36.7500268 C16,37.9926462 17.0073752,39.0000215 18.2499946,39.0000215 L49.7499195,39.0000215 Z M46.3749276,36.1875282 C45.4429459,36.1875282 44.6874316,35.4320139 44.6874316,34.5000322 C44.6874316,33.5680505 45.4429459,32.8125362 46.3749276,32.8125362 C47.3069093,32.8125362 48.0624236,33.5680505 48.0624236,34.5000322 C48.0624236,35.4320139 47.3069093,36.1875282 46.3749276,36.1875282 Z M41.8749383,36.1875282 C40.9429566,36.1875282 40.1874423,35.4320139 40.1874423,34.5000322 C40.1874423,33.5680505 40.9429566,32.8125362 41.8749383,32.8125362 C42.80692,32.8125362 43.5624343,33.5680505 43.5624343,34.5000322 C43.5624343,35.4320139 42.80692,36.1875282 41.8749383,36.1875282 Z M49.7499195,50.2499946 C50.9925389,50.2499946 51.9999142,49.2426194 51.9999142,48 L51.9999142,43.5000107 C51.9999142,42.2573913 50.9925389,41.2500161 49.7499195,41.2500161 L18.2499946,41.2500161 C17.0073752,41.2500161 16,42.2573913 16,43.5000107 L16,48 C16,49.2426194 17.0073752,50.2499946 18.2499946,50.2499946 L49.7499195,50.2499946 Z M46.3749276,47.4375013 C45.4429459,47.4375013 44.6874316,46.6819871 44.6874316,45.7500054 C44.6874316,44.8180236 45.4429459,44.0625094 46.3749276,44.0625094 C47.3069093,44.0625094 48.0624236,44.8180236 48.0624236,45.7500054 C48.0624236,46.6819871 47.3069093,47.4375013 46.3749276,47.4375013 Z M41.8749383,47.4375013 C40.9429566,47.4375013 40.1874423,46.6819871 40.1874423,45.7500054 C40.1874423,44.8180236 40.9429566,44.0625094 41.8749383,44.0625094 C42.80692,44.0625094 43.5624343,44.8180236 43.5624343,45.7500054 C43.5624343,46.6819871 42.80692,47.4375013 41.8749383,47.4375013 Z" id="s" fill="#FFFFFF" fill-rule="nonzero"></path>
-        </g>
-    </g>
-</svg>
\ No newline at end of file
diff --git a/docs/assets/icons/sdk.svg b/docs/assets/icons/sdk.svg
deleted file mode 100644
index 25cdebf4f30..00000000000
--- a/docs/assets/icons/sdk.svg
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="68px" height="68px" viewBox="0 0 68 68" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    <title>Server Copy</title>
-    <g id="Dumpster" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <g id="Server-Copy">
-            <circle id="Oval-Copy-5" fill="#00B06D" cx="34" cy="34" r="34"></circle>
-            <path d="M49.9999142,41.9999428 L49.9999142,21 C49.9999142,19.3499724 48.6499418,18 46.9999213,18 L20.9999905,18 C19.3499628,18 17.9999905,19.3499724 17.9999905,21 L17.9999905,41.9999428 L49.9999142,41.9999428 Z M45.9999237,37.9999523 L21.9999809,37.9999523 L21.9999809,21.9999905 L45.9999237,21.9999905 L45.9999237,37.9999523 Z M31.3537184,34.3531104 L32.0605649,33.6462029 C32.4511889,33.2555789 32.4511889,32.6224627 32.0605649,32.2318386 L29.8280873,29.9999714 L32.0599545,27.7674938 C32.4505786,27.3768697 32.4505786,26.7437536 32.0599545,26.3531295 L31.353108,25.646222 C30.962484,25.2555979 30.3293068,25.2555979 29.9386827,25.646222 L26.2924512,29.2924535 C25.9018271,29.6830776 25.9018271,30.3161938 26.2924512,30.7068178 L29.9393541,34.3531104 C30.3299782,34.7437345 30.9630943,34.7437345 31.3537184,34.3531104 Z M38.0612219,34.3537208 L41.7074535,30.7074892 C42.0980775,30.3168652 42.0980775,29.683749 41.7074535,29.2931249 L38.0612219,25.6468324 C37.6705979,25.2562083 37.0374207,25.2562083 36.6467966,25.6468324 L35.9399501,26.3537398 C35.5493261,26.7443639 35.5493261,27.3774801 35.9399501,27.7681042 L38.1718174,29.9999714 L35.9399501,32.232449 C35.5493261,32.623073 35.5493261,33.2561892 35.9399501,33.6468133 L36.6467966,34.3537208 C37.0374207,34.7443448 37.6705979,34.7443448 38.0612219,34.3537208 Z M49.9999142,49.9999237 C52.1999211,49.9999237 53.9999046,48.1999402 53.9999046,45.999938 L53.9999046,44.999938 C53.9999046,44.4499491 53.5498935,43.999938 52.999907,43.999938 L37.8461956,43.999938 C37.799931,45.2380332 36.9268252,45.999938 35.7999358,45.999938 L31.9999571,45.999938 C30.831808,45.999938 29.9362413,44.9080779 29.9518663,43.999938 L15,43.999938 C14.4500111,43.999938 14,44.4499491 14,44.999938 L14,45.999938 C14,48.1999402 15.7999835,49.9999237 18,49.9999237 L49.9999142,49.9999237 Z" id="l" fill="#FFFFFF" fill-rule="nonzero"></path>
-        </g>
-    </g>
-</svg>
\ No newline at end of file
diff --git a/docs/assets/info/query.png b/docs/assets/info/query.png
deleted file mode 100644
index 48301f93d97..00000000000
Binary files a/docs/assets/info/query.png and /dev/null differ
diff --git a/docs/assets/info/select.png b/docs/assets/info/select.png
deleted file mode 100644
index 731cf3e3257..00000000000
Binary files a/docs/assets/info/select.png and /dev/null differ
diff --git a/docs/assets/install-dependencies-gui-x.png b/docs/assets/install-dependencies-gui-x.png
deleted file mode 100644
index a4afc61191c..00000000000
Binary files a/docs/assets/install-dependencies-gui-x.png and /dev/null differ
diff --git a/docs/assets/integration-image.png b/docs/assets/integration-image.png
deleted file mode 100644
index 20a2feb7ff8..00000000000
Binary files a/docs/assets/integration-image.png and /dev/null differ
diff --git a/docs/assets/lightwood.png b/docs/assets/lightwood.png
deleted file mode 100644
index d55f5c7fe5e..00000000000
Binary files a/docs/assets/lightwood.png and /dev/null differ
diff --git a/docs/assets/mdb_image.png b/docs/assets/mdb_image.png
deleted file mode 100644
index 84a7720081f..00000000000
Binary files a/docs/assets/mdb_image.png and /dev/null differ
diff --git a/docs/assets/mdb_logo.png b/docs/assets/mdb_logo.png
deleted file mode 100755
index 7e1ee76aebd..00000000000
Binary files a/docs/assets/mdb_logo.png and /dev/null differ
diff --git a/docs/assets/mdb_logo_name.png b/docs/assets/mdb_logo_name.png
deleted file mode 100755
index 88374501af6..00000000000
Binary files a/docs/assets/mdb_logo_name.png and /dev/null differ
diff --git a/docs/assets/mdb_logo_w.svg b/docs/assets/mdb_logo_w.svg
deleted file mode 100644
index cd35d4eddab..00000000000
--- a/docs/assets/mdb_logo_w.svg
+++ /dev/null
@@ -1 +0,0 @@
-<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 96 96"><defs><style>.cls-1{fill:#fff;}</style></defs><title>MindsDBPolarBear</title><path class="cls-1" d="M80,46.63a2,2,0,0,1-.25.32c-3.81,3.21-3.81,3.21-8.55,1.67-2.71-.88-5.45-1.7-8.13-2.64a2.57,2.57,0,0,0-2.4.24c-2.78,1.74-5.57,3.47-8.37,5.16a2.38,2.38,0,0,0-1.18,1.9c-.57,3.84-1.24,7.66-1.82,11.5-.13.91-.54,1.16-1.44,1.2-5.47.21-5.47.24-5.41-5.25,0-2.19,0-4.38.1-6.56,0-1-.29-1.4-1.34-1.42-5.05-.13-10.09-.28-15.13-.52-1.13,0-1.3.55-1.49,1.35C23.72,57.3,22.79,61,22,64.74c-.21,1-.61,1.21-1.55,1.2-4.79,0-4.79,0-4.75-4.88s.11-9.61.12-14.41a4.59,4.59,0,0,1,.82-2.72c3-4.33,6.05-8.67,9-13.06A2.23,2.23,0,0,1,28,29.75c7.19.8,14.38,1.55,21.56,2.33,2.6.28,5.19.73,7.79.85a8,8,0,0,1,4.18,1.52c5.61,3.73,11.26,7.41,16.88,11.11C79,45.89,79.44,46.25,80,46.63Z"/><path class="cls-1" d="M61.25,48.42c.71,5.92,1.34,11.41,2,16.88.12,1,0,1.27-1,1.31-4,.18-4,.21-5.42-3.45a14.3,14.3,0,0,0-1-2.53c-1.87-2.94-1.17-5.29,1.31-7.52A51.23,51.23,0,0,0,61.25,48.42Z"/><path class="cls-1" d="M35.24,53.47c.78,4,1.48,7.73,2.23,11.43.2,1-.22,1-.95.88-.42-.09-.83-.19-1.25-.24-4-.47-4-.48-5-4.34A2.38,2.38,0,0,1,31,58.67C32.41,57.09,33.7,55.36,35.24,53.47Z"/></svg>
\ No newline at end of file
diff --git a/docs/assets/mindsdb-local-editor.png b/docs/assets/mindsdb-local-editor.png
deleted file mode 100644
index 0aa8d85e0f5..00000000000
Binary files a/docs/assets/mindsdb-local-editor.png and /dev/null differ
diff --git a/docs/assets/mindsdb_gui_editor/learning_hub.png b/docs/assets/mindsdb_gui_editor/learning_hub.png
deleted file mode 100644
index ecb700afafd..00000000000
Binary files a/docs/assets/mindsdb_gui_editor/learning_hub.png and /dev/null differ
diff --git a/docs/assets/mindsdb_homepage_diagram.png b/docs/assets/mindsdb_homepage_diagram.png
deleted file mode 100644
index c77fc5b623f..00000000000
Binary files a/docs/assets/mindsdb_homepage_diagram.png and /dev/null differ
diff --git a/docs/assets/mindsdb_logo.png b/docs/assets/mindsdb_logo.png
deleted file mode 100644
index 2dc5824d871..00000000000
Binary files a/docs/assets/mindsdb_logo.png and /dev/null differ
diff --git a/docs/assets/predictors/clickhouse-insert.gif b/docs/assets/predictors/clickhouse-insert.gif
deleted file mode 100644
index b1161582f69..00000000000
Binary files a/docs/assets/predictors/clickhouse-insert.gif and /dev/null differ
diff --git a/docs/assets/predictors/clickhouse-query.gif b/docs/assets/predictors/clickhouse-query.gif
deleted file mode 100644
index 76d231b4a2a..00000000000
Binary files a/docs/assets/predictors/clickhouse-query.gif and /dev/null differ
diff --git a/docs/assets/predictors/column-importance.png b/docs/assets/predictors/column-importance.png
deleted file mode 100644
index 565d0fde145..00000000000
Binary files a/docs/assets/predictors/column-importance.png and /dev/null differ
diff --git a/docs/assets/predictors/mariadb-insert.gif b/docs/assets/predictors/mariadb-insert.gif
deleted file mode 100644
index 795d61c6f61..00000000000
Binary files a/docs/assets/predictors/mariadb-insert.gif and /dev/null differ
diff --git a/docs/assets/predictors/mariadb-status.gif b/docs/assets/predictors/mariadb-status.gif
deleted file mode 100644
index 98be86a25c8..00000000000
Binary files a/docs/assets/predictors/mariadb-status.gif and /dev/null differ
diff --git a/docs/assets/predictors/mongo/mongo-insert.gif b/docs/assets/predictors/mongo/mongo-insert.gif
deleted file mode 100644
index 39d36ca5be3..00000000000
Binary files a/docs/assets/predictors/mongo/mongo-insert.gif and /dev/null differ
diff --git a/docs/assets/predictors/mssql-status.gif b/docs/assets/predictors/mssql-status.gif
deleted file mode 100644
index c7e617b7923..00000000000
Binary files a/docs/assets/predictors/mssql-status.gif and /dev/null differ
diff --git a/docs/assets/predictors/mysql-insert.gif b/docs/assets/predictors/mysql-insert.gif
deleted file mode 100644
index 2eeb0bd0f7e..00000000000
Binary files a/docs/assets/predictors/mysql-insert.gif and /dev/null differ
diff --git a/docs/assets/predictors/mysql-query.gif b/docs/assets/predictors/mysql-query.gif
deleted file mode 100644
index 611f2fd76b3..00000000000
Binary files a/docs/assets/predictors/mysql-query.gif and /dev/null differ
diff --git a/docs/assets/predictors/mysql-status.gif b/docs/assets/predictors/mysql-status.gif
deleted file mode 100644
index 96ee51fc6db..00000000000
Binary files a/docs/assets/predictors/mysql-status.gif and /dev/null differ
diff --git a/docs/assets/predictors/postgresql-insert.gif b/docs/assets/predictors/postgresql-insert.gif
deleted file mode 100644
index 08ed88afe93..00000000000
Binary files a/docs/assets/predictors/postgresql-insert.gif and /dev/null differ
diff --git a/docs/assets/predictors/postgresql-status.gif b/docs/assets/predictors/postgresql-status.gif
deleted file mode 100644
index 8fe657ac8f2..00000000000
Binary files a/docs/assets/predictors/postgresql-status.gif and /dev/null differ
diff --git a/docs/assets/predictors/train-advanced.gif b/docs/assets/predictors/train-advanced.gif
deleted file mode 100644
index 2bed2542a40..00000000000
Binary files a/docs/assets/predictors/train-advanced.gif and /dev/null differ
diff --git a/docs/assets/predictors/train-timeseries.gif b/docs/assets/predictors/train-timeseries.gif
deleted file mode 100644
index 891ccf8d944..00000000000
Binary files a/docs/assets/predictors/train-timeseries.gif and /dev/null differ
diff --git a/docs/assets/report-issue.gif b/docs/assets/report-issue.gif
deleted file mode 100644
index f2f770bfa5c..00000000000
Binary files a/docs/assets/report-issue.gif and /dev/null differ
diff --git a/docs/assets/report_issues/1_issue_types.png b/docs/assets/report_issues/1_issue_types.png
deleted file mode 100644
index 35f5b80f559..00000000000
Binary files a/docs/assets/report_issues/1_issue_types.png and /dev/null differ
diff --git a/docs/assets/report_issues/1_reporting_new_issue.png b/docs/assets/report_issues/1_reporting_new_issue.png
deleted file mode 100644
index 331a1ba3148..00000000000
Binary files a/docs/assets/report_issues/1_reporting_new_issue.png and /dev/null differ
diff --git a/docs/assets/report_issues/2_bug_report.png b/docs/assets/report_issues/2_bug_report.png
deleted file mode 100644
index 23b8ad0454c..00000000000
Binary files a/docs/assets/report_issues/2_bug_report.png and /dev/null differ
diff --git a/docs/assets/report_issues/2_bug_report_form_1.png b/docs/assets/report_issues/2_bug_report_form_1.png
deleted file mode 100644
index b5b9a21fa75..00000000000
Binary files a/docs/assets/report_issues/2_bug_report_form_1.png and /dev/null differ
diff --git a/docs/assets/report_issues/2_bug_report_form_2.png b/docs/assets/report_issues/2_bug_report_form_2.png
deleted file mode 100644
index ad9790049b2..00000000000
Binary files a/docs/assets/report_issues/2_bug_report_form_2.png and /dev/null differ
diff --git a/docs/assets/report_issues/2_bug_report_form_3.png b/docs/assets/report_issues/2_bug_report_form_3.png
deleted file mode 100644
index 866dab3ed89..00000000000
Binary files a/docs/assets/report_issues/2_bug_report_form_3.png and /dev/null differ
diff --git a/docs/assets/report_issues/2_bug_report_form_4.png b/docs/assets/report_issues/2_bug_report_form_4.png
deleted file mode 100644
index 090879b2724..00000000000
Binary files a/docs/assets/report_issues/2_bug_report_form_4.png and /dev/null differ
diff --git a/docs/assets/report_issues/2_bug_report_form_5.png b/docs/assets/report_issues/2_bug_report_form_5.png
deleted file mode 100644
index 9522dafaa46..00000000000
Binary files a/docs/assets/report_issues/2_bug_report_form_5.png and /dev/null differ
diff --git a/docs/assets/report_issues/3_feature_request.png b/docs/assets/report_issues/3_feature_request.png
deleted file mode 100644
index a40bf424f17..00000000000
Binary files a/docs/assets/report_issues/3_feature_request.png and /dev/null differ
diff --git a/docs/assets/report_issues/3_feature_request_form_1.png b/docs/assets/report_issues/3_feature_request_form_1.png
deleted file mode 100644
index 72b959d883c..00000000000
Binary files a/docs/assets/report_issues/3_feature_request_form_1.png and /dev/null differ
diff --git a/docs/assets/report_issues/3_feature_request_form_2.png b/docs/assets/report_issues/3_feature_request_form_2.png
deleted file mode 100644
index 7798e3113f7..00000000000
Binary files a/docs/assets/report_issues/3_feature_request_form_2.png and /dev/null differ
diff --git a/docs/assets/report_issues/3_feature_request_form_3.png b/docs/assets/report_issues/3_feature_request_form_3.png
deleted file mode 100644
index 0c328662c15..00000000000
Binary files a/docs/assets/report_issues/3_feature_request_form_3.png and /dev/null differ
diff --git a/docs/assets/report_issues/3_feature_request_form_4.png b/docs/assets/report_issues/3_feature_request_form_4.png
deleted file mode 100644
index dcf29dec23d..00000000000
Binary files a/docs/assets/report_issues/3_feature_request_form_4.png and /dev/null differ
diff --git a/docs/assets/report_issues/4_improve_docs.png b/docs/assets/report_issues/4_improve_docs.png
deleted file mode 100644
index 6d4c6bd2a4b..00000000000
Binary files a/docs/assets/report_issues/4_improve_docs.png and /dev/null differ
diff --git a/docs/assets/report_issues/4_improve_docs_form_1.png b/docs/assets/report_issues/4_improve_docs_form_1.png
deleted file mode 100644
index 34555ee09c4..00000000000
Binary files a/docs/assets/report_issues/4_improve_docs_form_1.png and /dev/null differ
diff --git a/docs/assets/report_issues/4_improve_docs_form_2.png b/docs/assets/report_issues/4_improve_docs_form_2.png
deleted file mode 100644
index 6c74fc78e26..00000000000
Binary files a/docs/assets/report_issues/4_improve_docs_form_2.png and /dev/null differ
diff --git a/docs/assets/report_issues/4_improve_docs_form_3.png b/docs/assets/report_issues/4_improve_docs_form_3.png
deleted file mode 100644
index 3ad7ad6bf45..00000000000
Binary files a/docs/assets/report_issues/4_improve_docs_form_3.png and /dev/null differ
diff --git a/docs/assets/report_issues/5_new_integration.png b/docs/assets/report_issues/5_new_integration.png
deleted file mode 100644
index 76d538124b4..00000000000
Binary files a/docs/assets/report_issues/5_new_integration.png and /dev/null differ
diff --git a/docs/assets/report_issues/5_new_integration_form_1.png b/docs/assets/report_issues/5_new_integration_form_1.png
deleted file mode 100644
index faff515679c..00000000000
Binary files a/docs/assets/report_issues/5_new_integration_form_1.png and /dev/null differ
diff --git a/docs/assets/report_issues/5_new_integration_form_2.png b/docs/assets/report_issues/5_new_integration_form_2.png
deleted file mode 100644
index 10b02645877..00000000000
Binary files a/docs/assets/report_issues/5_new_integration_form_2.png and /dev/null differ
diff --git a/docs/assets/report_issues/5_new_integration_form_3.png b/docs/assets/report_issues/5_new_integration_form_3.png
deleted file mode 100644
index 7ef021fb9cb..00000000000
Binary files a/docs/assets/report_issues/5_new_integration_form_3.png and /dev/null differ
diff --git a/docs/assets/report_issues/5_new_integration_form_4.png b/docs/assets/report_issues/5_new_integration_form_4.png
deleted file mode 100644
index 64afecdb6db..00000000000
Binary files a/docs/assets/report_issues/5_new_integration_form_4.png and /dev/null differ
diff --git a/docs/assets/report_issues/5_new_integration_form_5.png b/docs/assets/report_issues/5_new_integration_form_5.png
deleted file mode 100644
index e278788c71b..00000000000
Binary files a/docs/assets/report_issues/5_new_integration_form_5.png and /dev/null differ
diff --git a/docs/assets/report_issues/5_new_integration_form_6.png b/docs/assets/report_issues/5_new_integration_form_6.png
deleted file mode 100644
index a9bed7296e7..00000000000
Binary files a/docs/assets/report_issues/5_new_integration_form_6.png and /dev/null differ
diff --git a/docs/assets/report_issues/6_security_vulnerability.png b/docs/assets/report_issues/6_security_vulnerability.png
deleted file mode 100644
index 8b31fcba775..00000000000
Binary files a/docs/assets/report_issues/6_security_vulnerability.png and /dev/null differ
diff --git a/docs/assets/report_issues/6_security_vulnerability_form_1.png b/docs/assets/report_issues/6_security_vulnerability_form_1.png
deleted file mode 100644
index ffb45993174..00000000000
Binary files a/docs/assets/report_issues/6_security_vulnerability_form_1.png and /dev/null differ
diff --git a/docs/assets/report_issues/6_security_vulnerability_form_2.png b/docs/assets/report_issues/6_security_vulnerability_form_2.png
deleted file mode 100644
index e8305dd7a72..00000000000
Binary files a/docs/assets/report_issues/6_security_vulnerability_form_2.png and /dev/null differ
diff --git a/docs/assets/report_issues/6_security_vulnerability_form_3.png b/docs/assets/report_issues/6_security_vulnerability_form_3.png
deleted file mode 100644
index 1339a145e54..00000000000
Binary files a/docs/assets/report_issues/6_security_vulnerability_form_3.png and /dev/null differ
diff --git a/docs/assets/report_issues/6_security_vulnerability_form_4.png b/docs/assets/report_issues/6_security_vulnerability_form_4.png
deleted file mode 100644
index 45efe6f28be..00000000000
Binary files a/docs/assets/report_issues/6_security_vulnerability_form_4.png and /dev/null differ
diff --git a/docs/assets/report_issues/6_security_vulnerability_form_5.png b/docs/assets/report_issues/6_security_vulnerability_form_5.png
deleted file mode 100644
index c594a715d9c..00000000000
Binary files a/docs/assets/report_issues/6_security_vulnerability_form_5.png and /dev/null differ
diff --git a/docs/assets/sentiment_analysis_diagram.png b/docs/assets/sentiment_analysis_diagram.png
deleted file mode 100644
index d163a6843da..00000000000
Binary files a/docs/assets/sentiment_analysis_diagram.png and /dev/null differ
diff --git a/docs/assets/sql/add-file-data.png b/docs/assets/sql/add-file-data.png
deleted file mode 100644
index d5ff62b99c1..00000000000
Binary files a/docs/assets/sql/add-file-data.png and /dev/null differ
diff --git a/docs/assets/sql/analytics_shift.png b/docs/assets/sql/analytics_shift.png
deleted file mode 100644
index 8ee0d7526d2..00000000000
Binary files a/docs/assets/sql/analytics_shift.png and /dev/null differ
diff --git a/docs/assets/sql/connectcloud.png b/docs/assets/sql/connectcloud.png
deleted file mode 100644
index da88ef566ad..00000000000
Binary files a/docs/assets/sql/connectcloud.png and /dev/null differ
diff --git a/docs/assets/sql/connectdb.png b/docs/assets/sql/connectdb.png
deleted file mode 100644
index a76dd4cd10a..00000000000
Binary files a/docs/assets/sql/connectdb.png and /dev/null differ
diff --git a/docs/assets/sql/datasource.gif b/docs/assets/sql/datasource.gif
deleted file mode 100644
index fef984cadfa..00000000000
Binary files a/docs/assets/sql/datasource.gif and /dev/null differ
diff --git a/docs/assets/sql/datasource_listing.png b/docs/assets/sql/datasource_listing.png
deleted file mode 100644
index f54dbd61be6..00000000000
Binary files a/docs/assets/sql/datasource_listing.png and /dev/null differ
diff --git a/docs/assets/sql/dbeaver-local.png b/docs/assets/sql/dbeaver-local.png
deleted file mode 100644
index 1200e1586d7..00000000000
Binary files a/docs/assets/sql/dbeaver-local.png and /dev/null differ
diff --git a/docs/assets/sql/dbeaver8.png b/docs/assets/sql/dbeaver8.png
deleted file mode 100644
index ccc23fa0b37..00000000000
Binary files a/docs/assets/sql/dbeaver8.png and /dev/null differ
diff --git a/docs/assets/sql/drop.png b/docs/assets/sql/drop.png
deleted file mode 100644
index 2b9cbd213cb..00000000000
Binary files a/docs/assets/sql/drop.png and /dev/null differ
diff --git a/docs/assets/sql/file.png b/docs/assets/sql/file.png
deleted file mode 100644
index 2cbaa03f960..00000000000
Binary files a/docs/assets/sql/file.png and /dev/null differ
diff --git a/docs/assets/sql/machine_learning_lifecycle.png b/docs/assets/sql/machine_learning_lifecycle.png
deleted file mode 100644
index f52f642decf..00000000000
Binary files a/docs/assets/sql/machine_learning_lifecycle.png and /dev/null differ
diff --git a/docs/assets/sql/mysql-client.gif b/docs/assets/sql/mysql-client.gif
deleted file mode 100644
index 3bbd821221f..00000000000
Binary files a/docs/assets/sql/mysql-client.gif and /dev/null differ
diff --git a/docs/assets/sql/select.png b/docs/assets/sql/select.png
deleted file mode 100644
index e580d64c835..00000000000
Binary files a/docs/assets/sql/select.png and /dev/null differ
diff --git a/docs/assets/sql/select_bulk.png b/docs/assets/sql/select_bulk.png
deleted file mode 100644
index 0ba44b132f3..00000000000
Binary files a/docs/assets/sql/select_bulk.png and /dev/null differ
diff --git a/docs/assets/sql/select_file.png b/docs/assets/sql/select_file.png
deleted file mode 100644
index 306b84b67b2..00000000000
Binary files a/docs/assets/sql/select_file.png and /dev/null differ
diff --git a/docs/assets/sql/select_hr.png b/docs/assets/sql/select_hr.png
deleted file mode 100644
index febe5cf5249..00000000000
Binary files a/docs/assets/sql/select_hr.png and /dev/null differ
diff --git a/docs/assets/sql/select_hra.png b/docs/assets/sql/select_hra.png
deleted file mode 100644
index b3024153e21..00000000000
Binary files a/docs/assets/sql/select_hra.png and /dev/null differ
diff --git a/docs/assets/sql/show.png b/docs/assets/sql/show.png
deleted file mode 100644
index 9e3c9f089c8..00000000000
Binary files a/docs/assets/sql/show.png and /dev/null differ
diff --git a/docs/assets/sql/status.png b/docs/assets/sql/status.png
deleted file mode 100644
index e4a4e846d05..00000000000
Binary files a/docs/assets/sql/status.png and /dev/null differ
diff --git a/docs/assets/sql/test_connection_dbeaver.png b/docs/assets/sql/test_connection_dbeaver.png
deleted file mode 100644
index b53e1d25367..00000000000
Binary files a/docs/assets/sql/test_connection_dbeaver.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/Mushrooms/Selection_004.png b/docs/assets/sql/tutorials/Mushrooms/Selection_004.png
deleted file mode 100644
index 60765f6734e..00000000000
Binary files a/docs/assets/sql/tutorials/Mushrooms/Selection_004.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/Mushrooms/create.png b/docs/assets/sql/tutorials/Mushrooms/create.png
deleted file mode 100644
index a58fb5170fa..00000000000
Binary files a/docs/assets/sql/tutorials/Mushrooms/create.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/Mushrooms/database.png b/docs/assets/sql/tutorials/Mushrooms/database.png
deleted file mode 100644
index da64041148c..00000000000
Binary files a/docs/assets/sql/tutorials/Mushrooms/database.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/Mushrooms/dbintegration.png b/docs/assets/sql/tutorials/Mushrooms/dbintegration.png
deleted file mode 100644
index 5011c8b514b..00000000000
Binary files a/docs/assets/sql/tutorials/Mushrooms/dbintegration.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/Mushrooms/mushroomsselect.png b/docs/assets/sql/tutorials/Mushrooms/mushroomsselect.png
deleted file mode 100644
index 63462cfd043..00000000000
Binary files a/docs/assets/sql/tutorials/Mushrooms/mushroomsselect.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/Mushrooms/prediction.png b/docs/assets/sql/tutorials/Mushrooms/prediction.png
deleted file mode 100644
index 4077748ab11..00000000000
Binary files a/docs/assets/sql/tutorials/Mushrooms/prediction.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/Mushrooms/statuscheck.png b/docs/assets/sql/tutorials/Mushrooms/statuscheck.png
deleted file mode 100644
index a9225ed4139..00000000000
Binary files a/docs/assets/sql/tutorials/Mushrooms/statuscheck.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/bodyfat/connect-database.png b/docs/assets/sql/tutorials/bodyfat/connect-database.png
deleted file mode 100644
index 1f4bc04e0c7..00000000000
Binary files a/docs/assets/sql/tutorials/bodyfat/connect-database.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/bodyfat/create.png b/docs/assets/sql/tutorials/bodyfat/create.png
deleted file mode 100644
index 1c29ba80331..00000000000
Binary files a/docs/assets/sql/tutorials/bodyfat/create.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/bodyfat/database-connected.png b/docs/assets/sql/tutorials/bodyfat/database-connected.png
deleted file mode 100644
index 7de3cbfa5f0..00000000000
Binary files a/docs/assets/sql/tutorials/bodyfat/database-connected.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/bodyfat/join.png b/docs/assets/sql/tutorials/bodyfat/join.png
deleted file mode 100644
index 34e271329ea..00000000000
Binary files a/docs/assets/sql/tutorials/bodyfat/join.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/bodyfat/prediction.png b/docs/assets/sql/tutorials/bodyfat/prediction.png
deleted file mode 100644
index ccb29486ab5..00000000000
Binary files a/docs/assets/sql/tutorials/bodyfat/prediction.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/bodyfat/selectdata.png b/docs/assets/sql/tutorials/bodyfat/selectdata.png
deleted file mode 100644
index 2dba31a42f5..00000000000
Binary files a/docs/assets/sql/tutorials/bodyfat/selectdata.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/bodyfat/status.png b/docs/assets/sql/tutorials/bodyfat/status.png
deleted file mode 100644
index 205bdebb9c0..00000000000
Binary files a/docs/assets/sql/tutorials/bodyfat/status.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/bodyfat/upload_file.png b/docs/assets/sql/tutorials/bodyfat/upload_file.png
deleted file mode 100644
index 971f921735f..00000000000
Binary files a/docs/assets/sql/tutorials/bodyfat/upload_file.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/connect.gif b/docs/assets/sql/tutorials/connect.gif
deleted file mode 100644
index a9c96e0c84f..00000000000
Binary files a/docs/assets/sql/tutorials/connect.gif and /dev/null differ
diff --git a/docs/assets/sql/tutorials/connect.png b/docs/assets/sql/tutorials/connect.png
deleted file mode 100644
index 3a5f3e60c0b..00000000000
Binary files a/docs/assets/sql/tutorials/connect.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/create_ds.gif b/docs/assets/sql/tutorials/create_ds.gif
deleted file mode 100644
index 6d8e61f9670..00000000000
Binary files a/docs/assets/sql/tutorials/create_ds.gif and /dev/null differ
diff --git a/docs/assets/sql/tutorials/crop-prediction/database-integration-mariadb.png b/docs/assets/sql/tutorials/crop-prediction/database-integration-mariadb.png
deleted file mode 100644
index 82c012e883c..00000000000
Binary files a/docs/assets/sql/tutorials/crop-prediction/database-integration-mariadb.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/customer_churn/create_churn.png b/docs/assets/sql/tutorials/customer_churn/create_churn.png
deleted file mode 100644
index e8e09d8c433..00000000000
Binary files a/docs/assets/sql/tutorials/customer_churn/create_churn.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/customer_churn/customer_churn.png b/docs/assets/sql/tutorials/customer_churn/customer_churn.png
deleted file mode 100644
index b512debb315..00000000000
Binary files a/docs/assets/sql/tutorials/customer_churn/customer_churn.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/customer_churn/customer_churn2.png b/docs/assets/sql/tutorials/customer_churn/customer_churn2.png
deleted file mode 100644
index 5dd32ae5069..00000000000
Binary files a/docs/assets/sql/tutorials/customer_churn/customer_churn2.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/customer_churn/select.png b/docs/assets/sql/tutorials/customer_churn/select.png
deleted file mode 100644
index 0431e61d605..00000000000
Binary files a/docs/assets/sql/tutorials/customer_churn/select.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/customer_churn/upload.png b/docs/assets/sql/tutorials/customer_churn/upload.png
deleted file mode 100644
index 9cd89702011..00000000000
Binary files a/docs/assets/sql/tutorials/customer_churn/upload.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/1prediction.png b/docs/assets/sql/tutorials/heart-disease/1prediction.png
deleted file mode 100644
index 386ee0d5986..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/1prediction.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/2.1prediction.png b/docs/assets/sql/tutorials/heart-disease/2.1prediction.png
deleted file mode 100644
index 694db4a5ca0..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/2.1prediction.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/2ndprediction.png b/docs/assets/sql/tutorials/heart-disease/2ndprediction.png
deleted file mode 100644
index 61eb5cb9652..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/2ndprediction.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/3rdprediction.png b/docs/assets/sql/tutorials/heart-disease/3rdprediction.png
deleted file mode 100644
index 1d6e5e886fa..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/3rdprediction.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/connect_db.png b/docs/assets/sql/tutorials/heart-disease/connect_db.png
deleted file mode 100644
index d2ff26c758b..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/connect_db.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/connect_mysql_client.png b/docs/assets/sql/tutorials/heart-disease/connect_mysql_client.png
deleted file mode 100644
index 045900c4288..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/connect_mysql_client.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/create.png b/docs/assets/sql/tutorials/heart-disease/create.png
deleted file mode 100644
index c2d19f2ce2c..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/create.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/create_predictor.png b/docs/assets/sql/tutorials/heart-disease/create_predictor.png
deleted file mode 100644
index f0a87aac086..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/create_predictor.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/database.png b/docs/assets/sql/tutorials/heart-disease/database.png
deleted file mode 100644
index d607c7a540c..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/database.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/dataselection.png b/docs/assets/sql/tutorials/heart-disease/dataselection.png
deleted file mode 100644
index 400b1d0231a..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/dataselection.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/dbintegration.png b/docs/assets/sql/tutorials/heart-disease/dbintegration.png
deleted file mode 100644
index 5011c8b514b..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/dbintegration.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/join_query.gif b/docs/assets/sql/tutorials/heart-disease/join_query.gif
deleted file mode 100644
index 2b41dc45d7d..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/join_query.gif and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/predictor_status.png b/docs/assets/sql/tutorials/heart-disease/predictor_status.png
deleted file mode 100644
index 7c86f66666a..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/predictor_status.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/select_prediction_query.png b/docs/assets/sql/tutorials/heart-disease/select_prediction_query.png
deleted file mode 100644
index 1ae0639d1e4..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/select_prediction_query.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/selectpredictor.png b/docs/assets/sql/tutorials/heart-disease/selectpredictor.png
deleted file mode 100644
index d28cc8575b4..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/selectpredictor.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/heart-disease/use_mindsdb.png b/docs/assets/sql/tutorials/heart-disease/use_mindsdb.png
deleted file mode 100644
index e5aade0af41..00000000000
Binary files a/docs/assets/sql/tutorials/heart-disease/use_mindsdb.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insert.png b/docs/assets/sql/tutorials/insert.png
deleted file mode 100644
index 8f2fa8df549..00000000000
Binary files a/docs/assets/sql/tutorials/insert.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/add-database-cloud-mindsdb-sql.png b/docs/assets/sql/tutorials/insurance-cost-prediction/add-database-cloud-mindsdb-sql.png
deleted file mode 100644
index 039e479fd66..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/add-database-cloud-mindsdb-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/connect-mindsdb-sql.png b/docs/assets/sql/tutorials/insurance-cost-prediction/connect-mindsdb-sql.png
deleted file mode 100644
index 28f4f5936d5..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/connect-mindsdb-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/create-prediction-bitcoin-sql.png b/docs/assets/sql/tutorials/insurance-cost-prediction/create-prediction-bitcoin-sql.png
deleted file mode 100644
index 1ba4621c05b..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/create-prediction-bitcoin-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/create-prediction-isurance-sql.png b/docs/assets/sql/tutorials/insurance-cost-prediction/create-prediction-isurance-sql.png
deleted file mode 100644
index dd71194df5e..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/create-prediction-isurance-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/create-predictor-bitcoin-sql.png b/docs/assets/sql/tutorials/insurance-cost-prediction/create-predictor-bitcoin-sql.png
deleted file mode 100644
index 0688bebeac3..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/create-predictor-bitcoin-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/create-predictor-insurance-sql.png b/docs/assets/sql/tutorials/insurance-cost-prediction/create-predictor-insurance-sql.png
deleted file mode 100644
index 9937b9e4a82..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/create-predictor-insurance-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/show-bitcoin-table.png b/docs/assets/sql/tutorials/insurance-cost-prediction/show-bitcoin-table.png
deleted file mode 100644
index 1970b54c5a9..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/show-bitcoin-table.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/show-databases-sql.png b/docs/assets/sql/tutorials/insurance-cost-prediction/show-databases-sql.png
deleted file mode 100644
index 540e119131e..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/show-databases-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/show-insurance-table.png b/docs/assets/sql/tutorials/insurance-cost-prediction/show-insurance-table.png
deleted file mode 100644
index 1006202b031..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/show-insurance-table.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/show-predictor-bitcoin-sql.png b/docs/assets/sql/tutorials/insurance-cost-prediction/show-predictor-bitcoin-sql.png
deleted file mode 100644
index b3302211ebf..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/show-predictor-bitcoin-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/show-predictor-isurance-sql.png b/docs/assets/sql/tutorials/insurance-cost-prediction/show-predictor-isurance-sql.png
deleted file mode 100644
index e3a4cf0832b..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/show-predictor-isurance-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/show-tables-sql-2.png b/docs/assets/sql/tutorials/insurance-cost-prediction/show-tables-sql-2.png
deleted file mode 100644
index 6a695cbef93..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/show-tables-sql-2.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/show-tables-sql.png b/docs/assets/sql/tutorials/insurance-cost-prediction/show-tables-sql.png
deleted file mode 100644
index 119fa2222ef..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/show-tables-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost-prediction/success-connect-sql.png b/docs/assets/sql/tutorials/insurance-cost-prediction/success-connect-sql.png
deleted file mode 100644
index 21bcd93c307..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost-prediction/success-connect-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/add-database-cloud-mindsdb-sql.png b/docs/assets/sql/tutorials/insurance-cost/add-database-cloud-mindsdb-sql.png
deleted file mode 100644
index 039e479fd66..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/add-database-cloud-mindsdb-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/connect-mindsdb-sql.png b/docs/assets/sql/tutorials/insurance-cost/connect-mindsdb-sql.png
deleted file mode 100644
index 28f4f5936d5..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/connect-mindsdb-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/create-prediction-isurance-sql.png b/docs/assets/sql/tutorials/insurance-cost/create-prediction-isurance-sql.png
deleted file mode 100644
index dd71194df5e..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/create-prediction-isurance-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/create-predictor-insurance-sql.png b/docs/assets/sql/tutorials/insurance-cost/create-predictor-insurance-sql.png
deleted file mode 100644
index 9937b9e4a82..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/create-predictor-insurance-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/create_db.png b/docs/assets/sql/tutorials/insurance-cost/create_db.png
deleted file mode 100644
index 0397217b658..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/create_db.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/insurance_predictor.png b/docs/assets/sql/tutorials/insurance-cost/insurance_predictor.png
deleted file mode 100644
index f0eccd7686e..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/insurance_predictor.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/prediction_insurance.png b/docs/assets/sql/tutorials/insurance-cost/prediction_insurance.png
deleted file mode 100644
index 484efef6678..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/prediction_insurance.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/select_insurance.png b/docs/assets/sql/tutorials/insurance-cost/select_insurance.png
deleted file mode 100644
index fdf0ee65a9b..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/select_insurance.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/show-databases-sql.png b/docs/assets/sql/tutorials/insurance-cost/show-databases-sql.png
deleted file mode 100644
index 540e119131e..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/show-databases-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/show-insurance-table.png b/docs/assets/sql/tutorials/insurance-cost/show-insurance-table.png
deleted file mode 100644
index 1006202b031..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/show-insurance-table.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/show-predictor-isurance-sql.png b/docs/assets/sql/tutorials/insurance-cost/show-predictor-isurance-sql.png
deleted file mode 100644
index e3a4cf0832b..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/show-predictor-isurance-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/show-tables-sql-2.png b/docs/assets/sql/tutorials/insurance-cost/show-tables-sql-2.png
deleted file mode 100644
index 6a695cbef93..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/show-tables-sql-2.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/show-tables-sql.png b/docs/assets/sql/tutorials/insurance-cost/show-tables-sql.png
deleted file mode 100644
index 119fa2222ef..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/show-tables-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/insurance-cost/success-connect-sql.png b/docs/assets/sql/tutorials/insurance-cost/success-connect-sql.png
deleted file mode 100644
index 21bcd93c307..00000000000
Binary files a/docs/assets/sql/tutorials/insurance-cost/success-connect-sql.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/process-quality/database-integration.png b/docs/assets/sql/tutorials/process-quality/database-integration.png
deleted file mode 100644
index fe96f4c119e..00000000000
Binary files a/docs/assets/sql/tutorials/process-quality/database-integration.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/process-quality/database.png b/docs/assets/sql/tutorials/process-quality/database.png
deleted file mode 100644
index d607c7a540c..00000000000
Binary files a/docs/assets/sql/tutorials/process-quality/database.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/process-quality/dbintegration.png b/docs/assets/sql/tutorials/process-quality/dbintegration.png
deleted file mode 100644
index 5011c8b514b..00000000000
Binary files a/docs/assets/sql/tutorials/process-quality/dbintegration.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/select.png b/docs/assets/sql/tutorials/select.png
deleted file mode 100644
index 2fa767edccb..00000000000
Binary files a/docs/assets/sql/tutorials/select.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/selecti.png b/docs/assets/sql/tutorials/selecti.png
deleted file mode 100644
index 4cce94e7e26..00000000000
Binary files a/docs/assets/sql/tutorials/selecti.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/1-ML_audience.png b/docs/assets/sql/tutorials/snowflake-superset/1-ML_audience.png
deleted file mode 100644
index a9f65cb53e6..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/1-ML_audience.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/10-DBeaver connection.png b/docs/assets/sql/tutorials/snowflake-superset/10-DBeaver connection.png
deleted file mode 100644
index 8722f1c41cd..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/10-DBeaver connection.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/11-Dbeaver2.png b/docs/assets/sql/tutorials/snowflake-superset/11-Dbeaver2.png
deleted file mode 100644
index 42690cc8298..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/11-Dbeaver2.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/12-show_dtabases.png b/docs/assets/sql/tutorials/snowflake-superset/12-show_dtabases.png
deleted file mode 100644
index 71ec0af4a88..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/12-show_dtabases.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/13-info_schema.png b/docs/assets/sql/tutorials/snowflake-superset/13-info_schema.png
deleted file mode 100644
index 7d0ff3a0b90..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/13-info_schema.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/14-table.png b/docs/assets/sql/tutorials/snowflake-superset/14-table.png
deleted file mode 100644
index 7a15d17fdad..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/14-table.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/15-query.png b/docs/assets/sql/tutorials/snowflake-superset/15-query.png
deleted file mode 100644
index 3dd98bb2c6b..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/15-query.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/16-predictive_query.png b/docs/assets/sql/tutorials/snowflake-superset/16-predictive_query.png
deleted file mode 100644
index 46164d46d65..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/16-predictive_query.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/17-stops_by_route_Superset.jpg b/docs/assets/sql/tutorials/snowflake-superset/17-stops_by_route_Superset.jpg
deleted file mode 100644
index c131dce035b..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/17-stops_by_route_Superset.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/18-timeseries_chart.jpg b/docs/assets/sql/tutorials/snowflake-superset/18-timeseries_chart.jpg
deleted file mode 100644
index bf4d473c0a6..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/18-timeseries_chart.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/19-timeseries2.jpg b/docs/assets/sql/tutorials/snowflake-superset/19-timeseries2.jpg
deleted file mode 100644
index 2d44bec204c..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/19-timeseries2.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/2-ML_workflow.png b/docs/assets/sql/tutorials/snowflake-superset/2-ML_workflow.png
deleted file mode 100644
index 7775334643e..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/2-ML_workflow.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/20-filters1.jpg b/docs/assets/sql/tutorials/snowflake-superset/20-filters1.jpg
deleted file mode 100644
index 44adb88da32..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/20-filters1.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/20-filters2.jpg b/docs/assets/sql/tutorials/snowflake-superset/20-filters2.jpg
deleted file mode 100644
index eebecd869f5..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/20-filters2.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/21-graph.jpg b/docs/assets/sql/tutorials/snowflake-superset/21-graph.jpg
deleted file mode 100644
index 1a41b0e0541..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/21-graph.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/22-graph.jpg b/docs/assets/sql/tutorials/snowflake-superset/22-graph.jpg
deleted file mode 100644
index 57cf5ae4bec..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/22-graph.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/23-graph.jpg b/docs/assets/sql/tutorials/snowflake-superset/23-graph.jpg
deleted file mode 100644
index 7bf3035448c..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/23-graph.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/24-MindsDB_ML-Workflow.png b/docs/assets/sql/tutorials/snowflake-superset/24-MindsDB_ML-Workflow.png
deleted file mode 100644
index ba0bc2c9c51..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/24-MindsDB_ML-Workflow.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/3-AI_Tables-income-debt.jpg b/docs/assets/sql/tutorials/snowflake-superset/3-AI_Tables-income-debt.jpg
deleted file mode 100644
index c3a3c3d6001..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/3-AI_Tables-income-debt.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/3-AI_Tables-income_table.jpg b/docs/assets/sql/tutorials/snowflake-superset/3-AI_Tables-income_table.jpg
deleted file mode 100644
index 71b8e3d8058..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/3-AI_Tables-income_table.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/4-AI_Tables-income-debt-query.jpg b/docs/assets/sql/tutorials/snowflake-superset/4-AI_Tables-income-debt-query.jpg
deleted file mode 100644
index 19ce5b15f7d..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/4-AI_Tables-income-debt-query.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/4-debt_vs_income.png b/docs/assets/sql/tutorials/snowflake-superset/4-debt_vs_income.png
deleted file mode 100644
index d1e5c60ab06..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/4-debt_vs_income.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/5-debt-income-query-table.jpg b/docs/assets/sql/tutorials/snowflake-superset/5-debt-income-query-table.jpg
deleted file mode 100644
index 12966b717d6..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/5-debt-income-query-table.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/5-debt-income-query.jpg b/docs/assets/sql/tutorials/snowflake-superset/5-debt-income-query.jpg
deleted file mode 100644
index 8fed6732107..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/5-debt-income-query.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/6-debt-income-query-null-table.jpg b/docs/assets/sql/tutorials/snowflake-superset/6-debt-income-query-null-table.jpg
deleted file mode 100644
index 25b6415008b..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/6-debt-income-query-null-table.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/6-debt-income-query-null.jpg b/docs/assets/sql/tutorials/snowflake-superset/6-debt-income-query-null.jpg
deleted file mode 100644
index 2122c847f60..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/6-debt-income-query-null.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/7-debt-income-query-ml-table.jpg b/docs/assets/sql/tutorials/snowflake-superset/7-debt-income-query-ml-table.jpg
deleted file mode 100644
index eb4735d750f..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/7-debt-income-query-ml-table.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/7-debt-income-query-ml.jpg b/docs/assets/sql/tutorials/snowflake-superset/7-debt-income-query-ml.jpg
deleted file mode 100644
index 36c4225f717..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/7-debt-income-query-ml.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/8-multivariate_problem.jpg b/docs/assets/sql/tutorials/snowflake-superset/8-multivariate_problem.jpg
deleted file mode 100644
index 8e437b53e23..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/8-multivariate_problem.jpg and /dev/null differ
diff --git a/docs/assets/sql/tutorials/snowflake-superset/9-connect_to_MindsDB.png b/docs/assets/sql/tutorials/snowflake-superset/9-connect_to_MindsDB.png
deleted file mode 100644
index 45e505128f4..00000000000
Binary files a/docs/assets/sql/tutorials/snowflake-superset/9-connect_to_MindsDB.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/status.png b/docs/assets/sql/tutorials/status.png
deleted file mode 100644
index a60ad71df42..00000000000
Binary files a/docs/assets/sql/tutorials/status.png and /dev/null differ
diff --git a/docs/assets/sql/tutorials/use.png b/docs/assets/sql/tutorials/use.png
deleted file mode 100644
index 25f47fbe9ec..00000000000
Binary files a/docs/assets/sql/tutorials/use.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-clickhouse/describe-table.png b/docs/assets/tutorials/aitables-clickhouse/describe-table.png
deleted file mode 100644
index c10d33fc8d0..00000000000
Binary files a/docs/assets/tutorials/aitables-clickhouse/describe-table.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-clickhouse/select-info.png b/docs/assets/tutorials/aitables-clickhouse/select-info.png
deleted file mode 100644
index fc9fee0a20d..00000000000
Binary files a/docs/assets/tutorials/aitables-clickhouse/select-info.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-clickhouse/select-info2.png b/docs/assets/tutorials/aitables-clickhouse/select-info2.png
deleted file mode 100644
index 215fce4a09e..00000000000
Binary files a/docs/assets/tutorials/aitables-clickhouse/select-info2.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-clickhouse/show-tables.png b/docs/assets/tutorials/aitables-clickhouse/show-tables.png
deleted file mode 100644
index d5081904f6c..00000000000
Binary files a/docs/assets/tutorials/aitables-clickhouse/show-tables.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mariadb/database.png b/docs/assets/tutorials/aitables-mariadb/database.png
deleted file mode 100644
index a53ec9a4667..00000000000
Binary files a/docs/assets/tutorials/aitables-mariadb/database.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mariadb/mdb-maria.png b/docs/assets/tutorials/aitables-mariadb/mdb-maria.png
deleted file mode 100644
index d4293d55ba2..00000000000
Binary files a/docs/assets/tutorials/aitables-mariadb/mdb-maria.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mariadb/mdb-ver.png b/docs/assets/tutorials/aitables-mariadb/mdb-ver.png
deleted file mode 100644
index 0e741b06d95..00000000000
Binary files a/docs/assets/tutorials/aitables-mariadb/mdb-ver.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mariadb/predicted-info.png b/docs/assets/tutorials/aitables-mariadb/predicted-info.png
deleted file mode 100644
index 78c90805f88..00000000000
Binary files a/docs/assets/tutorials/aitables-mariadb/predicted-info.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mariadb/predicted.png b/docs/assets/tutorials/aitables-mariadb/predicted.png
deleted file mode 100644
index e004f66ee76..00000000000
Binary files a/docs/assets/tutorials/aitables-mariadb/predicted.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mariadb/predicted1.png b/docs/assets/tutorials/aitables-mariadb/predicted1.png
deleted file mode 100644
index aa15856adb0..00000000000
Binary files a/docs/assets/tutorials/aitables-mariadb/predicted1.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mariadb/select-data.png b/docs/assets/tutorials/aitables-mariadb/select-data.png
deleted file mode 100644
index edf1f79f0ca..00000000000
Binary files a/docs/assets/tutorials/aitables-mariadb/select-data.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mariadb/training-finish.png b/docs/assets/tutorials/aitables-mariadb/training-finish.png
deleted file mode 100644
index 90650d48663..00000000000
Binary files a/docs/assets/tutorials/aitables-mariadb/training-finish.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mariadb/training-run.png b/docs/assets/tutorials/aitables-mariadb/training-run.png
deleted file mode 100644
index 44c8736e2f2..00000000000
Binary files a/docs/assets/tutorials/aitables-mariadb/training-run.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mariadb/training.png b/docs/assets/tutorials/aitables-mariadb/training.png
deleted file mode 100644
index 658fa1dff8f..00000000000
Binary files a/docs/assets/tutorials/aitables-mariadb/training.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mssql/AI Tables.jpg b/docs/assets/tutorials/aitables-mssql/AI Tables.jpg
deleted file mode 100644
index 12af031ca62..00000000000
Binary files a/docs/assets/tutorials/aitables-mssql/AI Tables.jpg and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mssql/train-model.png b/docs/assets/tutorials/aitables-mssql/train-model.png
deleted file mode 100644
index c722f0c6ee3..00000000000
Binary files a/docs/assets/tutorials/aitables-mssql/train-model.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mysql/list_tables.png b/docs/assets/tutorials/aitables-mysql/list_tables.png
deleted file mode 100644
index ce044c906b0..00000000000
Binary files a/docs/assets/tutorials/aitables-mysql/list_tables.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mysql/select_status.png b/docs/assets/tutorials/aitables-mysql/select_status.png
deleted file mode 100644
index 4d40ac3fd5a..00000000000
Binary files a/docs/assets/tutorials/aitables-mysql/select_status.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-mysql/select_table.png b/docs/assets/tutorials/aitables-mysql/select_table.png
deleted file mode 100644
index f7e9ed4b014..00000000000
Binary files a/docs/assets/tutorials/aitables-mysql/select_table.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-postgresql/list_schema.png b/docs/assets/tutorials/aitables-postgresql/list_schema.png
deleted file mode 100644
index 3d982cf610a..00000000000
Binary files a/docs/assets/tutorials/aitables-postgresql/list_schema.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-postgresql/mindsdb_started.png b/docs/assets/tutorials/aitables-postgresql/mindsdb_started.png
deleted file mode 100644
index 243c2d6c2bb..00000000000
Binary files a/docs/assets/tutorials/aitables-postgresql/mindsdb_started.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-postgresql/select_model.png b/docs/assets/tutorials/aitables-postgresql/select_model.png
deleted file mode 100644
index 0c30c1a440a..00000000000
Binary files a/docs/assets/tutorials/aitables-postgresql/select_model.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-postgresql/select_status.png b/docs/assets/tutorials/aitables-postgresql/select_status.png
deleted file mode 100644
index 08eaea986a1..00000000000
Binary files a/docs/assets/tutorials/aitables-postgresql/select_status.png and /dev/null differ
diff --git a/docs/assets/tutorials/aitables-postgresql/select_table.png b/docs/assets/tutorials/aitables-postgresql/select_table.png
deleted file mode 100644
index c5b4f6b07eb..00000000000
Binary files a/docs/assets/tutorials/aitables-postgresql/select_table.png and /dev/null differ
diff --git a/docs/assets/tutorials/crops/2ndprediction.png b/docs/assets/tutorials/crops/2ndprediction.png
deleted file mode 100644
index 208516c42c8..00000000000
Binary files a/docs/assets/tutorials/crops/2ndprediction.png and /dev/null differ
diff --git a/docs/assets/tutorials/crops/createcropspredictor.png b/docs/assets/tutorials/crops/createcropspredictor.png
deleted file mode 100644
index bdaf210462f..00000000000
Binary files a/docs/assets/tutorials/crops/createcropspredictor.png and /dev/null differ
diff --git a/docs/assets/tutorials/crops/cropprediction.png b/docs/assets/tutorials/crops/cropprediction.png
deleted file mode 100644
index f70b75753e8..00000000000
Binary files a/docs/assets/tutorials/crops/cropprediction.png and /dev/null differ
diff --git a/docs/assets/tutorials/crops/database.png b/docs/assets/tutorials/crops/database.png
deleted file mode 100644
index d607c7a540c..00000000000
Binary files a/docs/assets/tutorials/crops/database.png and /dev/null differ
diff --git a/docs/assets/tutorials/crops/select_datasource.png b/docs/assets/tutorials/crops/select_datasource.png
deleted file mode 100644
index ace649d18cf..00000000000
Binary files a/docs/assets/tutorials/crops/select_datasource.png and /dev/null differ
diff --git a/docs/assets/tutorials/crops/selectfromfiles.png b/docs/assets/tutorials/crops/selectfromfiles.png
deleted file mode 100644
index f0cb9fa4ebf..00000000000
Binary files a/docs/assets/tutorials/crops/selectfromfiles.png and /dev/null differ
diff --git a/docs/assets/tutorials/crops/statuscheck.png b/docs/assets/tutorials/crops/statuscheck.png
deleted file mode 100644
index 49f8b56a13c..00000000000
Binary files a/docs/assets/tutorials/crops/statuscheck.png and /dev/null differ
diff --git a/docs/assets/tutorials/diabetes/Connecting_database_to_MindsdbCloud.gif b/docs/assets/tutorials/diabetes/Connecting_database_to_MindsdbCloud.gif
deleted file mode 100644
index ec838c4aeb3..00000000000
Binary files a/docs/assets/tutorials/diabetes/Connecting_database_to_MindsdbCloud.gif and /dev/null differ
diff --git a/docs/assets/tutorials/diabetes/DBdiabetes.png b/docs/assets/tutorials/diabetes/DBdiabetes.png
deleted file mode 100644
index 6eac862fc64..00000000000
Binary files a/docs/assets/tutorials/diabetes/DBdiabetes.png and /dev/null differ
diff --git a/docs/assets/tutorials/diabetes/connecting_mysql_client.gif b/docs/assets/tutorials/diabetes/connecting_mysql_client.gif
deleted file mode 100644
index 07534bfad86..00000000000
Binary files a/docs/assets/tutorials/diabetes/connecting_mysql_client.gif and /dev/null differ
diff --git a/docs/assets/tutorials/diabetes/create_predictor.png b/docs/assets/tutorials/diabetes/create_predictor.png
deleted file mode 100644
index 0f0288411b1..00000000000
Binary files a/docs/assets/tutorials/diabetes/create_predictor.png and /dev/null differ
diff --git a/docs/assets/tutorials/diabetes/database.png b/docs/assets/tutorials/diabetes/database.png
deleted file mode 100644
index d607c7a540c..00000000000
Binary files a/docs/assets/tutorials/diabetes/database.png and /dev/null differ
diff --git a/docs/assets/tutorials/diabetes/pg4admin/diabetes_logo.png b/docs/assets/tutorials/diabetes/pg4admin/diabetes_logo.png
deleted file mode 100644
index 29b54b8f4bd..00000000000
Binary files a/docs/assets/tutorials/diabetes/pg4admin/diabetes_logo.png and /dev/null differ
diff --git a/docs/assets/tutorials/diabetes/pg4admin/images.png b/docs/assets/tutorials/diabetes/pg4admin/images.png
deleted file mode 100644
index 7aa8fa107b6..00000000000
Binary files a/docs/assets/tutorials/diabetes/pg4admin/images.png and /dev/null differ
diff --git a/docs/assets/tutorials/diabetes/pg4admin/index.jpeg b/docs/assets/tutorials/diabetes/pg4admin/index.jpeg
deleted file mode 100644
index b4488fe8a58..00000000000
Binary files a/docs/assets/tutorials/diabetes/pg4admin/index.jpeg and /dev/null differ
diff --git a/docs/assets/tutorials/diabetes/prediction.png b/docs/assets/tutorials/diabetes/prediction.png
deleted file mode 100644
index 2f1badedd68..00000000000
Binary files a/docs/assets/tutorials/diabetes/prediction.png and /dev/null differ
diff --git a/docs/assets/tutorials/diabetes/predictor.png b/docs/assets/tutorials/diabetes/predictor.png
deleted file mode 100644
index dc446528989..00000000000
Binary files a/docs/assets/tutorials/diabetes/predictor.png and /dev/null differ
diff --git a/docs/assets/tutorials/diabetes/select_predictor.png b/docs/assets/tutorials/diabetes/select_predictor.png
deleted file mode 100644
index 472452bb893..00000000000
Binary files a/docs/assets/tutorials/diabetes/select_predictor.png and /dev/null differ
diff --git a/docs/assets/tutorials/llamaindex/1.ml_engine.png b/docs/assets/tutorials/llamaindex/1.ml_engine.png
deleted file mode 100644
index 7425e7e13f2..00000000000
Binary files a/docs/assets/tutorials/llamaindex/1.ml_engine.png and /dev/null differ
diff --git a/docs/assets/tutorials/llamaindex/2.create_model.png b/docs/assets/tutorials/llamaindex/2.create_model.png
deleted file mode 100644
index a118a16f6d0..00000000000
Binary files a/docs/assets/tutorials/llamaindex/2.create_model.png and /dev/null differ
diff --git a/docs/assets/tutorials/llamaindex/3.describe.png b/docs/assets/tutorials/llamaindex/3.describe.png
deleted file mode 100644
index b0f2546d04a..00000000000
Binary files a/docs/assets/tutorials/llamaindex/3.describe.png and /dev/null differ
diff --git a/docs/assets/tutorials/llamaindex/4.select_model.png b/docs/assets/tutorials/llamaindex/4.select_model.png
deleted file mode 100644
index b99e27a57b3..00000000000
Binary files a/docs/assets/tutorials/llamaindex/4.select_model.png and /dev/null differ
diff --git a/docs/assets/tutorials/llamaindex/5.batch.png b/docs/assets/tutorials/llamaindex/5.batch.png
deleted file mode 100644
index 6a49c9ccd14..00000000000
Binary files a/docs/assets/tutorials/llamaindex/5.batch.png and /dev/null differ
diff --git a/docs/assets/tutorials/monkeylearn/model3.png b/docs/assets/tutorials/monkeylearn/model3.png
deleted file mode 100644
index 6581255841a..00000000000
Binary files a/docs/assets/tutorials/monkeylearn/model3.png and /dev/null differ
diff --git a/docs/assets/tutorials/twitter_chatbot/Twitter-chatbot-mindsdb-mariadb-launch-skysql.png b/docs/assets/tutorials/twitter_chatbot/Twitter-chatbot-mindsdb-mariadb-launch-skysql.png
deleted file mode 100644
index c830cf0ac14..00000000000
Binary files a/docs/assets/tutorials/twitter_chatbot/Twitter-chatbot-mindsdb-mariadb-launch-skysql.png and /dev/null differ
diff --git a/docs/assets/tutorials/zero-shot-classification-postgresql-pg-admin.png b/docs/assets/tutorials/zero-shot-classification-postgresql-pg-admin.png
deleted file mode 100644
index 1f9f4379d53..00000000000
Binary files a/docs/assets/tutorials/zero-shot-classification-postgresql-pg-admin.png and /dev/null differ
diff --git a/docs/assets/tutorials/zero-shot-classification-postgresql.png b/docs/assets/tutorials/zero-shot-classification-postgresql.png
deleted file mode 100644
index 27e1a750d08..00000000000
Binary files a/docs/assets/tutorials/zero-shot-classification-postgresql.png and /dev/null differ
diff --git a/docs/assets/what_is_mindsdb.png b/docs/assets/what_is_mindsdb.png
deleted file mode 100644
index 6b54159e543..00000000000
Binary files a/docs/assets/what_is_mindsdb.png and /dev/null differ
diff --git a/docs/assets/what_is_mindsdb2.png b/docs/assets/what_is_mindsdb2.png
deleted file mode 100644
index 3d1508da6f1..00000000000
Binary files a/docs/assets/what_is_mindsdb2.png and /dev/null differ
diff --git a/docs/contribute/app-handlers.mdx b/docs/contribute/app-handlers.mdx
index 0c0a24639e1..040d3e2bc37 100644
--- a/docs/contribute/app-handlers.mdx
+++ b/docs/contribute/app-handlers.mdx
@@ -118,13 +118,13 @@ Here is a step-by-step guide:
     The `native_query()` method runs commands of the native API syntax.
 
     ```py
-    def native_query(self, query: Any) -> HandlerResponse:
+    def native_query(self, query: Any) -> TableResponse | OkResponse | ErrorResponse:
         """Receive raw query and act upon it somehow.
         Args:
             query (Any): query in native format (str for sql databases,
                 api's json etc)
         Returns:
-            HandlerResponse
+            TableResponse | OkResponse | ErrorResponse
         """
     ```
 
diff --git a/docs/contribute/data-handlers.mdx b/docs/contribute/data-handlers.mdx
index ca796627a7c..cb13aa0621d 100644
--- a/docs/contribute/data-handlers.mdx
+++ b/docs/contribute/data-handlers.mdx
@@ -45,7 +45,15 @@ Authors can opt for adding private methods, new files and folders, or any combin
 
     Under the `mindsdb.integrations.libs.utils` library, contributors can find various methods that may be useful while implementing new handlers.
 
-    Also, there are wrapper classes for the `DatabaseHandler` instances called [HandlerResponse](https://github.com/mindsdb/mindsdb/blob/main/mindsdb/integrations/libs/response.py#L7) and [HandlerStatusResponse](https://github.com/mindsdb/mindsdb/blob/main/mindsdb/integrations/libs/response.py#L32). You should use them to ensure proper output formatting.
+    For response formatting, use the following classes from `mindsdb.integrations.libs.response`:
+    - [TableResponse](https://github.com/mindsdb/mindsdb/blob/main/mindsdb/integrations/libs/response.py) - for queries returning data (SELECT, SHOW, etc.)
+    - [OkResponse](https://github.com/mindsdb/mindsdb/blob/main/mindsdb/integrations/libs/response.py) - for successful operations without data (CREATE, DROP, INSERT, etc.)
+    - [ErrorResponse](https://github.com/mindsdb/mindsdb/blob/main/mindsdb/integrations/libs/response.py) - for error cases
+    - [HandlerStatusResponse](https://github.com/mindsdb/mindsdb/blob/main/mindsdb/integrations/libs/response.py) - for connection status checks
+
+    <Warning>
+    The legacy `HandlerResponse` class is deprecated. Use `TableResponse`, `OkResponse`, or `ErrorResponse` instead.
+    </Warning>
 </Tip>
 
 ### Implementation
@@ -124,13 +132,13 @@ Here is a step-by-step guide:
     The `native_query()` method runs commands of the native database language.
 
     ```py
-    def native_query(self, query: Any) -> HandlerResponse:
+    def native_query(self, query: Any) -> TableResponse | OkResponse | ErrorResponse:
         """Receive raw query and act upon it somehow.
         Args:
             query (Any): query in native format (str for sql databases,
                 etc)
         Returns:
-            HandlerResponse
+            TableResponse | OkResponse | ErrorResponse
         """
     ```
 
@@ -139,13 +147,13 @@ Here is a step-by-step guide:
     The query method runs parsed SQL commands.
 
     ```py
-    def query(self, query: ASTNode) -> HandlerResponse:
+    def query(self, query: ASTNode) -> TableResponse | OkResponse | ErrorResponse:
         """Receive query as AST (abstract syntax tree) and act upon it somehow.
         Args:
             query (ASTNode): sql query represented as AST. May be any kind
                 of query: SELECT, INSERT, DELETE, etc
         Returns:
-            HandlerResponse
+            TableResponse | OkResponse | ErrorResponse
         """
     ```
 
@@ -154,11 +162,11 @@ Here is a step-by-step guide:
     The `get_tables()` method lists all the available tables.
 
     ```py
-    def get_tables(self) -> HandlerResponse:
+    def get_tables(self) -> TableResponse | ErrorResponse:
         """ Return list of entities
         Return a list of entities that will be accessible as tables.
         Returns:
-            HandlerResponse: should have the same columns as information_schema.tables
+            TableResponse | ErrorResponse: should have the same columns as information_schema.tables
                 (https://dev.mysql.com/doc/refman/8.0/en/information-schema-tables-table.html)
                 Column 'TABLE_NAME' is mandatory, other is optional.
         """
@@ -169,12 +177,12 @@ Here is a step-by-step guide:
     The `get_columns()` method lists all columns of a specified table.
 
     ```py
-    def get_columns(self, table_name: str) -> HandlerResponse:
+    def get_columns(self, table_name: str) -> TableResponse | ErrorResponse:
         """ Returns a list of entity columns
         Args:
             table_name (str): name of one of tables returned by self.get_tables()
         Returns:
-            HandlerResponse: should have the same columns as information_schema.columns
+            TableResponse | ErrorResponse: data should have the same columns as information_schema.columns
                 (https://dev.mysql.com/doc/refman/8.0/en/information-schema-columns-table.html)
                 Column 'COLUMN_NAME' is mandatory, other is optional. Highly
                 recommended to define also 'DATA_TYPE': it should be one of
@@ -182,6 +190,112 @@ Here is a step-by-step guide:
         """
     ```
 
+### Response Classes
+
+The data-returning methods (`native_query()`, `query()`, `get_tables()`, `get_columns()`) should return one of the following response classes from `mindsdb.integrations.libs.response`:
+
+| Response Class | Use Case | Key Attributes |
+|---------------|----------|----------------|
+| `TableResponse` | Queries that return data (SELECT, SHOW, etc.) | `data`, `data_generator`, `columns`, `affected_rows` |
+| `OkResponse` | Successful operations without data (CREATE, DROP, INSERT, UPDATE, DELETE) | `affected_rows` |
+| `ErrorResponse` | Error cases | `error_code`, `error_message`, `is_expected_error` |
+
+#### TableResponse
+
+`TableResponse` is used when returning data from queries. It supports two modes of data delivery:
+
+1. **Immediate data**: Pass all data at once via the `data` parameter (pandas DataFrame)
+2. **Streaming data**: Pass a generator via the `data_generator` parameter for lazy loading
+
+```py
+from mindsdb.integrations.libs.response import TableResponse, OkResponse, ErrorResponse
+
+# Immediate data response
+def native_query(self, query: str) -> TableResponse:
+    result = self.execute_query(query)
+    df = pd.DataFrame(result)
+    return TableResponse(data=df)
+
+# Streaming data response (for large datasets)
+def native_query(self, query: str) -> TableResponse:
+    def data_generator():
+        cursor = self.connection.cursor()
+        cursor.execute(query)
+        while batch := cursor.fetchmany(size=1000):
+            yield pd.DataFrame(batch)
+
+    return TableResponse(data_generator=data_generator())
+```
+
+#### OkResponse
+
+`OkResponse` is used for operations that don't return data:
+
+```py
+def native_query(self, query: str) -> OkResponse:
+    cursor = self.connection.cursor()
+    cursor.execute(query)
+    self.connection.commit()
+    return OkResponse(affected_rows=cursor.rowcount)
+```
+
+#### ErrorResponse
+
+`ErrorResponse` is used to report errors:
+
+```py
+def native_query(self, query: str) -> ErrorResponse:
+    try:
+        # ... execute query
+    except DatabaseError as e:
+        return ErrorResponse(
+            error_code=e.code,
+            error_message=str(e),
+            is_expected_error=True  # Set to True for user errors (syntax, permissions, etc.)
+        )
+```
+
+### Streaming Support
+
+For handlers that deal with large datasets, implementing streaming support is recommended. This allows data to be returned in chunks rather than loading everything into memory at once.
+
+To enable streaming:
+
+1. Set the `stream_response` class attribute to `True`:
+
+    ```py
+    class MyDatabaseHandler(DatabaseHandler):
+        name = "mydatabase"
+        stream_response = True  # Indicates that handler can return data as a generator
+    ```
+
+2. Implement `native_query()` to return a `TableResponse` with a `data_generator`:
+
+    ```py
+    def native_query(self, query: str, stream: bool = True) -> TableResponse | OkResponse | ErrorResponse:
+        if stream:
+            return self._execute_streaming(query)
+        else:
+            return self._execute_immediate(query)
+    
+    def _execute_streaming(self, query: str) -> TableResponse:
+        """Execute query and return results as a stream."""
+        cursor = self.connection.cursor(name="server_side_cursor")
+        cursor.execute(query)
+        
+        columns = [Column(name=col.name, type=col.type) for col in cursor.description]
+        
+        def generate_data():
+            while batch := cursor.fetchmany(size=1000):
+                yield pd.DataFrame(batch, columns=[c.name for c in columns])
+        
+        return TableResponse(columns=columns, data_generator=generate_data())
+    ```
+
+<Tip>
+For a complete example of streaming implementation, see the [PostgreSQL handler](https://github.com/mindsdb/mindsdb/blob/main/mindsdb/integrations/handlers/postgres_handler/postgres_handler.py).
+</Tip>
+
 ### Exporting the `connection_args` Dictionary
 
 The `connection_args` dictionary contains all of the arguments used to establish the connection along with their descriptions, types, labels, and whether they are required or not.
diff --git a/docs/docs.json b/docs/docs.json
index db577158115..ff5a1352eb2 100644
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -1085,14 +1085,6 @@
       "source": "/custom-model/mlflow",
       "destination": "/integrations/ai-engines/mlflow"
     },
-    {
-      "source": "/nixtla/statsforecast",
-      "destination": "/integrations/ai-engines/statsforecast"
-    },
-    {
-      "source": "/nixtla/house-sales-statsforecast",
-      "destination": "/sql/tutorials/house-sales-statsforecast"
-    },
     {
       "source": "/connect/mindsdb_editor",
       "destination": "/mindsdb_sql/connect/mindsdb_editor"
@@ -1377,10 +1369,6 @@
       "source": "/sql/tutorials/house-sales-forecasting",
       "destination": "/use-cases/predictive_analytics/house-sales-forecasting"
     },
-    {
-      "source": "/sql/tutorials/expenditures-statsforecast",
-      "destination": "/use-cases/predictive_analytics/expenditures-statsforecast"
-    },
     {
       "source": "/sql/tutorials/eeg-forecasting",
       "destination": "/use-cases/predictive_analytics/eeg-forecasting"
diff --git a/docs/integrations/ai-engines/byom.mdx b/docs/integrations/ai-engines/byom.mdx
index 736af426317..ffdc564ff57 100644
--- a/docs/integrations/ai-engines/byom.mdx
+++ b/docs/integrations/ai-engines/byom.mdx
@@ -25,7 +25,7 @@ Let's briefly go over the files that need to be uploaded:
 
     ```py
     class CustomPredictor():
-    ​
+    
         def train(self, df, target_col, args=None):
                 <implementation goes here>
                 return ''
@@ -39,38 +39,41 @@ Let's briefly go over the files that need to be uploaded:
     ```py
     import os
     import pandas as pd
-    ​
+    
     from sklearn.cross_decomposition import PLSRegression
     from sklearn import preprocessing
-    ​
+    
     class CustomPredictor():
-    ​
+    
         def train(self, df, target_col, args=None):
             print(args, '1111')
-    ​
+    
             self.target_col = target_col
             y = df[self.target_col]
             x = df.drop(columns=self.target_col)
             x_cols = list(x.columns)
-    ​
+    
             x_scaler = preprocessing.StandardScaler().fit(x)
             y_scaler = preprocessing.StandardScaler().fit(y.values.reshape(-1, 1))
-    ​
+    
             xs = x_scaler.transform(x)
             ys = y_scaler.transform(y.values.reshape(-1, 1))
-    ​
+    
             pls = PLSRegression(n_components=1)
             pls.fit(xs, ys)
-    ​
+
+            self.pls = pls
+            self.y_scaler = y_scaler
+
             T = pls.x_scores_
             W = pls.x_weights_
             P = pls.x_loadings_
             R = pls.x_rotations_
-    ​
+    
             self.x_cols = x_cols
             self.x_scaler = x_scaler
             self.P = P
-    ​
+    
             def calc_limit(df):
                 res = None
                 for column in df.columns:
@@ -89,32 +92,32 @@ Let's briefly go over the files that need to be uploaded:
                     except:
                         res = tbl
                 return res
-    ​
+    
             trdf = pd.DataFrame()
             trdf[self.target_col] = y.values
             trdf['T1'] = T.squeeze()
             limit = calc_limit(trdf).reset_index()
-    ​
+    
             self.limit = limit
-    ​
+    
             return "Trained predictor ready to be stored"
-    ​
+    
         def predict(self, df):
-    ​
-            yt = df[self.target_col].values
+    
+
             xt = df[self.x_cols]
-    ​
+    
             xt = self.x_scaler.transform(xt)
-    ​
+    
             excess_cols = list(set(df.columns) - set(self.x_cols))
-    ​
+    
             pred_df = df[excess_cols].copy()
-    ​
-            pred_df[self.target_col] = yt
+        
+            ys_pred = self.pls.predict(xt)
+            y_pred = self.y_scaler.inverse_transform(ys_pred).ravel()
+            pred_df[self.target_col] = y_pred
+
             pred_df['T1'] = (xt @ self.P).squeeze()
-    ​
-            pred_df = pd.merge(pred_df, self.limit[[self.target_col, 'lower', 'upper']], how='left', on=self.target_col)
-    ​
             return pred_df
     ```
 </Accordion>
@@ -195,12 +198,14 @@ USING
     ENGINE = 'custom_model_engine';
 ```
 
-Let's query for predictions by joining the custom model with the data table.
+Let's query for predictions by joining the custom model with the data table. Please note that when querying for predictions, do not include the target column in the `input` data selection.
 
 ```sql
-SELECT input.feature_column, model_target_column
-FROM my_integration.my_table as input
-JOIN custom_model as model;
+SELECT
+  input.feature_column,
+  model.target AS predicted_target
+FROM my_integration.my_table AS input
+JOIN custom_model AS model;
 ```
 
 <Info>
diff --git a/docs/integrations/ai-engines/neuralforecast.mdx b/docs/integrations/ai-engines/neuralforecast.mdx
deleted file mode 100644
index 619578e8552..00000000000
--- a/docs/integrations/ai-engines/neuralforecast.mdx
+++ /dev/null
@@ -1,200 +0,0 @@
----
-title: Nixtla's NeuralForecast Integration with MindsDB
-sidebarTitle: NeuralForecast
----
-
-Nixtla’s NeuralForecast provides a diverse array of neural forecasting models, prioritizing their ease of use and resilience. These models encompass a spectrum of options, including traditional networks like MLP and RNNs, as well as cutting-edge innovations such as NBEATS, NHITS, TFT, and various other architectural approaches.
-
-You can learn more about its features [here](https://nixtla.github.io/neuralforecast/).
-
-## How to bring NeuralForecast Models to MindsDB
-
-Before creating a model, you will need to create an ML engine for NeuralForecast using the `CREATE ML_ENGINE` statement:
-
-```sql
-CREATE ML_ENGINE neuralforecast
-FROM neuralforecast;
-```
-
-Once the ML engine is created, we use the `CREATE MODEL` statement to create the NeuralForecast model in MindsDB.
-
-```sql
-CREATE MODEL model_name
-FROM data_source
-  (SELECT * FROM table_name)
-PREDICT column_to_be_predicted
-GROUP BY column_name, column_name, ...
-ORDER BY date_column
-WINDOW 12 -- model looks back at sets of 12 rows each
-HORIZON 3 -- model forecasts the next 3 rows
-USING
-    engine = 'neuralforecast'
-    frequency = 'Q',
-    train_time = 0.01,
-    exogenous_vars = ['var_1', 'var_2'];
-```
-
-To ensure that the model is created based on the NeuralForecast engine, include the `USING` clause at the end.
-
-The `frequency` parameter informs the model about the expected time difference between each measurement ([supported values here](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases)). And the `train_time` parameter defines the training time - it defaults to 1, and lower values will reduce training time linearly by reducing the number of searches allowed for the best configuration by AutoNHITS. You can also define `exogenous_vars` as a parameter in the `USING` clause - these are complementary variables in the table that may improve forecast accuracy.
-
-## Example
-
-Let's go through an example of how to use Nixtla's NeuralForecast with MindsDB to forecast monthly expenditures based on historical data.
-
-Please note that before using the NeuralForecast engine, you should create it from the MindsDB editor, or other clients through which you interact with MindsDB, with the below command:
-
-```sql
-CREATE ML_ENGINE neuralforecast
-FROM neuralforecast;
-```
-
-You can check the available engines with this command:
-
-```sql
-SHOW ML_ENGINES;
-```
-
-If you see the NeuralForecast engine on the list, you are ready to follow the tutorials.
-
-We use a table from our MySQL public demo database, so let’s start by connecting MindsDB to it:
-
-```sql
-CREATE DATABASE mysql_demo_db
-WITH ENGINE = 'mysql',
-PARAMETERS = {
-    "user": "user",
-    "password": "MindsDBUser123!",
-    "host": "samples.mindsdb.com",
-    "port": "3306",
-    "database": "public"
-};
-```
-
-Now that we’ve connected our database to MindsDB, let’s query the data to be used in the example:
-
-```sql
-SELECT *
-FROM mysql_demo_db.historical_expenditures
-LIMIT 3;
-```
-
-Here is the output:
-
-```sql
-+------------+----------+-------------+
-| month      | category | expenditure |
-+------------+----------+-------------+
-| 1982-04-01 | clothing | 359.9       |
-| 1982-05-01 | clothing | 386.6       |
-| 1982-06-01 | clothing | 350.5       |
-+------------+----------+-------------+
-```
-
-The `historical_expenditures` table stores monthly expenditure data for various categories, such as `food`, `clothing`, `industry`, and more.
-
-Let's create a model table to predict the expenditures:
-
-```sql
-CREATE MODEL quarterly_expenditure_forecaster
-FROM mysql_demo_db
-  (SELECT * FROM historical_expenditures)
-PREDICT expenditure
-GROUP BY category
-ORDER BY month
-WINDOW 12
-HORIZON 3
-USING ENGINE = 'neuralforecast';
-```
-
-The `CREATE MODEL` statement creates, trains, and deploys the model. Here, we predict the `expenditure` column values. As it is a time series model, we order the data by the `month` column. Additionally, we group data by the `category` column - the predictions are made for each group independently (here, for each category).
-
-Next, we define the `WINDOW` and `HORIZON` clauses. The `WINDOW` clause specifies the number of rows we look back at (here, we look back at sets of 12 rows). And the `HORIZON` clause defines for how many rows the predictions are made (here, for the next 3 rows).
-
-<Tip>
-Please visit our docs on the [`CREATE MODEL`](/sql/create/model) statement to learn more.
-</Tip>
-
-The `ENGINE` parameter in the `USING` clause specifies the ML engine used to make predictions.
-
-We can check the training status with the following query:
-
-```sql
-DESCRIBE quarterly_expenditure_forecaster;
-```
-
-Once the model status is `complete`, the behavior is the same as with any other AI table – you can query for batch predictions by joining it with a data table:
-
-```sql
-SELECT m.month as month, m.expenditure as forecasted
-FROM mindsdb.quarterly_expenditure_forecaster as m
-JOIN mysql_demo_db.historical_expenditures as t
-WHERE t.month > LATEST
-AND t.category = 'clothing';
-```
-
-Here is the output data:
-
-```sql
-+----------------------------+------------------+
-| month                      | forecasted       |
-+----------------------------+------------------+
-| 2017-10-01 00:00:00.000000 | 10802.2109375    |
-| 2017-11-01 00:00:00.000000 | 10749.2041015625 |
-| 2017-12-01 00:00:00.000000 | 12423.849609375  |
-+----------------------------+------------------+
-```
-
-The `historical_expenditures` table is used to make batch predictions. Upon joining the `quarterly_expenditure_forecaster` model with the `historical_expenditures` table, we get predictions for the next quarter as defined by the `HORIZON 3` clause.
-
-Please note that the output `month` column contains both the date and timestamp. This format is used by default, as the timestamp is required when dealing with the hourly frequency of data.
-
-MindsDB provides the `LATEST` keyword that marks the latest training data point. In the `WHERE` clause, we specify the `month > LATEST` condition to ensure the predictions are made for data after the latest training data point.
-
-Let’s consider our `quarterly_expenditure_forecaster` model. We train the model using data until the third quarter of 2017, and the predictions come for the fourth quarter of 2017 (as defined by `HORIZON 3`).
-
-## NeuralForecast + HierarchicalForecast
-
-The NeuralForecast handler also supports hierarchical reconciliation via Nixtla’s [HierarchicalForecast package](https://nixtla.github.io/hierarchicalforecast/). Hierarchical reconciliation may improve prediction accuracy when the data has a hierarchical structure.
-
-In this example, there may be a hierarchy as total expenditure is comprised of 7 different categories.
-
-```sql
-SELECT DISTINCT category
-FROM mysql_demo_db.historical_expenditures;
-```
-
-Here are the available categories:
-
-```sql
-+-------------------+
-| category          |
-+-------------------+
-| food              |
-| household_goods   |
-| clothing          |
-| department_stores |
-| other             |
-| cafes             |
-| industry          |
-+-------------------+
-```
-
-Spending in each category may be related over time. For example, if spending on `food` rises in October 2017, it may be more likely that spending on `cafes` also rises in October 2017. Hierarchical reconciliation can account for this shared information.
-
-Here is how we can create a model:
-
-```sql
-CREATE MODEL hierarchical_expenditure_forecaster
-FROM mysql_demo_db
-  (SELECT * FROM historical_expenditures)
-PREDICT expenditure
-GROUP BY category
-ORDER BY month
-HORIZON 3
-USING
-  ENGINE = 'neuralforecast',
-  HIERARCHY = [‘category’];
-```
-
-Predictions with this model account for the hierarchical structure. The output may differ from the default model, which does not assume any hierarchy.
diff --git a/docs/integrations/ai-engines/ollama.mdx b/docs/integrations/ai-engines/ollama.mdx
index 287738d54b7..9cca48ce604 100644
--- a/docs/integrations/ai-engines/ollama.mdx
+++ b/docs/integrations/ai-engines/ollama.mdx
@@ -28,17 +28,17 @@ Here are the recommended system specifications:
 Create an AI engine from the [Ollama handler](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/ollama_handler).
 
 ```sql
-CREATE ML_ENGINE ollama_engine
+CREATE ML_ENGINE ollama
 FROM ollama;
 ```
 
-Create a model using `ollama_engine` as an engine.
+Create a model using `ollama` as an engine.
 
 ```sql
 CREATE MODEL ollama_model
 PREDICT completion
 USING
-   engine = 'ollama_engine',   -- engine name as created via CREATE ML_ENGINE
+   engine = 'ollama',   -- engine name as created via CREATE ML_ENGINE
    model_name = 'model-name',  -- model run with 'ollama run model-name'
    ollama_serve_url = 'http://localhost:11434';
 ```
@@ -51,7 +51,7 @@ You can find [available models here](https://github.com/ollama/ollama?tab=readme
 
 ## Usage
 
-The following usage examples utilize `ollama_engine` to create a model with the `CREATE MODEL` statement.
+The following usage examples utilize `ollama` to create a model with the `CREATE MODEL` statement.
 
 Deploy and use the `llama3` model.
 
@@ -63,7 +63,7 @@ Now deploy this model within MindsDB.
 CREATE MODEL llama3_model
 PREDICT completion
 USING
-   engine = 'ollama_engine',
+   engine = 'ollama',
    model_name = 'llama3';
 ```
 
diff --git a/docs/integrations/ai-engines/statsforecast.mdx b/docs/integrations/ai-engines/statsforecast.mdx
deleted file mode 100644
index 483b2c9c327..00000000000
--- a/docs/integrations/ai-engines/statsforecast.mdx
+++ /dev/null
@@ -1,359 +0,0 @@
----
-title: Nixtla's StatsForecast Integration with MindsDB
-sidebarTitle: StatsForecast
----
-
-Nixtla’s StatsForecast integration offers univariate time series forecasting models. StatsForecast uses classical methods such as ARIMA, rather than deep learning. Models train very quickly and generalize well, so are unlikely to overfit. Models also perform well on short time series, where deep learning models may be more likely to overfit.
-
-You can learn more about its features [here](https://nixtla.github.io/statsforecast/).
-
-## How to bring StatsForecast Models to MindsDB
-
-Before creating a model, you will need to create an ML engine for StatsForecast using the `CREATE ML_ENGINE` statement:
-
-```sql
-CREATE ML_ENGINE statsforecast
-FROM statsforecast;
-```
-
-Once the ML engine is created, we use the `CREATE MODEL` statement to create the StatsForecast model in MindsDB.
-
-```sql
-CREATE MODEL model_name
-FROM data_source
-  (SELECT * FROM table_name)
-PREDICT column_to_be_predicted
-GROUP BY column_name, column_name, ...
-ORDER BY date_column
-WINDOW 12 -- model looks back at sets of 12 rows each
-HORIZON 3 -- model forecasts the next 3 rows
-USING
-  engine = 'statsforecast',
-  model_name = 'model',
-  frequency = 'X',
-  season_length = 1,
-  hierarchy = ['column'];
-```
-
-The following parameters can be used while creating the StatsForecast model:
-
-- `model_name` is an optional parameter that lets users specify one of the models from [this list](https://github.com/Nixtla/statsforecast?tab=readme-ov-file#models), which otherwise is chosen automatically.
-- `frequency` is an optional parameter that defines the frequency of data such as daily, weekly, monthly, etc. Available values include "H", "M", "MS", "Q", "SM", "BM", "BMS", "BQ", "BH".        
-- `season_length` is an optional parameter that defines the length of the season depending on frequency. For instance, `season_length` defaults to `12` if `frequency` is set to `M` (months).
-- `hierarchy` is an optional parameter that may improve prediction accuracy when the data has a hierarchical structure. [See more here](/integrations/ai-engines/statsforecast#statsforecast-hierarchicalforecast).
-
-To ensure that the model is created based on the StatsForecast engine, include the `USING` clause at the end.
-
-## Example
-
-Let's go through an example of how to use Nixtla's StatsForecast with MindsDB to forecast monthly expenditures.
-
-Please note that before using the StatsForecast engine, you should create it from the MindsDB editor, or other clients through which you interact with MindsDB, with the below command:
-
-```sql
-CREATE ML_ENGINE statsforecast
-FROM statsforecast;
-```
-
-You can check the available engines with this command:
-
-```sql
-SHOW ML_ENGINES;
-```
-
-If you see the StatsForecast engine on the list, you are ready to follow the tutorials.
-
-### Tutorial using SQL
-
-In this tutorial, we create a model to predict expenditures based on historical data using the StatsForecast engine.
-
-We use a table from our MySQL public demo database, so let’s start by connecting MindsDB to it:
-
-```sql
-CREATE DATABASE mysql_demo_db
-WITH ENGINE = 'mysql',
-PARAMETERS = {
-    "user": "user",
-    "password": "MindsDBUser123!",
-    "host": "samples.mindsdb.com",
-    "port": "3306",
-    "database": "public"
-};
-```
-
-Now that we’ve connected our database to MindsDB, let’s query the data to be used in the example:
-
-```sql
-SELECT *
-FROM mysql_demo_db.historical_expenditures
-LIMIT 3;
-```
-
-Here is the output:
-
-```sql
-+------------+----------+-------------+
-| month      | category | expenditure |
-+------------+----------+-------------+
-| 1982-04-01 | food     | 1162.6      |
-| 1982-05-01 | food     | 1150.9      |
-| 1982-06-01 | food     | 1160        |
-+------------+----------+-------------+
-```
-
-The `historical_expenditures` table stores monthly expenditure data for various categories, such as `food`, `clothing`, `industry`, and more.
-
-Let's create a model table to predict the expenditures:
-
-```sql
-CREATE MODEL quarterly_expenditure_forecaster
-FROM mysql_demo_db
-  (SELECT * FROM historical_expenditures)
-PREDICT expenditure
-GROUP BY category
-ORDER BY month
-HORIZON 3
-USING ENGINE = 'statsforecast';
-```
-
-<Tip>
-Please visit our docs on the [`CREATE MODEL`](/sql/create/model) statement to learn more.
-</Tip>
-
-Please note that the `WINDOW` clause is not required because StatsForecast automatically calculates the best window as part of hyperparameter tuning.
-
-The `ENGINE` parameter in the `USING` clause specifies the ML engine used to make predictions.
-
-We can check the training status with the following query:
-
-```sql
-DESCRIBE quarterly_expenditure_forecaster;
-```
-
-One of the pros of using the StatsForecast engine is that it is fast - it doesn’t take long until the model completes the training process.
-
-Once the model status is `complete`, the behavior is the same as with any other AI table – you can query for batch predictions by joining it with a data table:
-
-```sql
-SELECT m.month as month, m.expenditure as forecasted
-FROM mindsdb.quarterly_expenditure_forecaster as m
-JOIN mysql_demo_db.historical_expenditures as t
-WHERE t.month > LATEST
-AND t.category = 'food';
-```
-
-Here is the output data:
-
-```sql
-+----------------------------+-----------------+
-| month                      | forecasted      |
-+----------------------------+-----------------+
-| 2017-10-01 00:00:00.000000 | 10256.251953125 |
-| 2017-11-01 00:00:00.000000 | 10182.58984375  |
-| 2017-12-01 00:00:00.000000 | 10316.259765625 |
-+----------------------------+-----------------+
-```
-
-The `historical_expenditures` table is used to make batch predictions. Upon joining the `quarterly_expenditure_forecaster` model with the `historical_expenditures` table, we get predictions for the next quarter as defined by the `HORIZON 3` clause.
-
-Please note that the output `month` column contains both the date and timestamp. This format is used by default, as the timestamp is required when dealing with the hourly frequency of data.
-
-MindsDB provides the `LATEST` keyword that marks the latest training data point. In the `WHERE` clause, we specify the `month > LATEST` condition to ensure the predictions are made for data after the latest training data point.
-
-Let’s consider our `quarterly_expenditure_forecaster` model. We train the model using data until the third quarter of 2017, and the predictions come for the fourth quarter of 2017 (as defined by `HORIZON 3`).
-
-### Tutorial using MQL
-
-In this tutorial, we create a model to predict expenditures based on historical data using the StatsForecast engine.
-
-Before we start, visit our docs to learn how to connect [Mongo Compass](https://docs.mindsdb.com/connect/mongo-compass) and [Mongo Shell](https://docs.mindsdb.com/connect/mongo-shell) to MindsDB.
-
-We use a collection from our Mongo public demo database, so let’s start by connecting MindsDB to it from Mongo Compass or Mongo Shell:
-
-```bash
-> use mindsdb
-> db.databases.insertOne({
-        'name': 'mongo_demo_db',
-        'engine': 'mongodb',
-        'connection_args': {
-            "host": "mongodb+srv://user:MindsDBUser123!@demo-data-mdb.trzfwvb.mongodb.net/",
-            "database": "public"
-        }
-   })
-```
-
-Now that we’ve connected our database to MindsDB, let’s query the data to be used in the example.
-
-```bash
-> use mongo_demo_db
-> db.historical_expenditures.find({}).limit(3)
-```
-
-Here is the output:
-
-```bash
-{
-  _id: '63fd2388bee7187f230f56fc',
-  month: '1982-04-01',
-  category: 'food',
-  expenditure: '1162.6'
-}
-{
-  _id: '63fd2388bee7187f230f56fd',
-  month: '1982-05-01',
-  category: 'food',
-  expenditure: '1150.9'
-}
-{
-  _id: '63fd2388bee7187f230f56fe',
-  month: '1982-06-01',
-  category: 'food',
-  expenditure: '1160'
-}
-```
-
-The `historical_expenditures` collection stores monthly expenditure data for various categories, such as `food`, `clothing`, `industry`, and more.
-
-Let's create a model to predict the expenditures:
-
-```bash
-> use mindsdb
-> db.predictors.insertOne({
-       name: 'quarterly_expenditure_forecaster',
-       predict: 'expenditure',
-       connection: 'mongo_demo_db',
-       select_data_query: 'db.historical_expenditures.find({})',
-       training_options: {
-          timeseries_settings: {                
-              order_by: ['month'],               
-              group_by: ['category'],
-              horizon: 3           
-          },
-          engine: 'statsforecast'
-      }  
-  })
-```
-
-<Tip>
-Please visit our docs on the [`insertOne`](/mongo/insert) statement to learn more.
-</Tip>
-
-Please note that the `window` clause is not required because StatsForecast automatically calculates the best window as part of hyperparameter tuning.
-
-The `engine` parameter in the `training_options` clause specifies the ML engine used to make predictions.
-
-We can check the training status with the following query:
-
-```bash
-> db.models.find({
-      name: 'quarterly_expenditure_forecaster'
-  })
-```
-
-One of the pros of using the StatsForecast engine is that it is fast - it doesn’t take long until the model completes the training process.
-
-Once the model status is `complete`, the behavior is the same as with any other AI collection – you can query for batch predictions by joining it with a data collection:
-
-```bash
-> db.quarterly_expenditure_forecaster.find({
-      "collection": "mongo_pred_01.historical_expenditures",
-      "query": {"category": "food"}
-  }).limit(3)
-```
-
-By default the forecasts are made for `month > LATEST`.
-
-Here is the output data:
-
-```bash
-{
-  _id: '63fd2388bee7187f230f58a5',
-  month: 2017-10-01T00:00:00.000Z,
-  category: 'food',
-  expenditure: 10256.251953125
-}
-{
-  _id: '63fd2388bee7187f230f58a4',
-  month: 2017-11-01T00:00:00.000Z,
-  category: 'food',
-  expenditure: 10182.58984375
-}
-{
-  _id: '63fd2388bee7187f230f58a3',
-  month: 2017-12-01T00:00:00.000Z,
-  category: 'food',
-  expenditure: 10316.259765625
-}
-```
-
-The `historical_expenditures` collection is used to make batch predictions. Upon joining the `quarterly_expenditure_forecaster` model with the `historical_expenditures` collection, we get predictions for the next quarter as defined by the `horizon: 3` clause.
-
-Please note that the output `month` column contains both the date and timestamp. This format is used by default, as the timestamp is required when dealing with the hourly frequency of data.
-
-MindsDB provides the `latest` keyword that marks the latest training data point. In the `where` clause, we specify the `month > latest` condition to ensure the predictions are made for data after the latest training data point.
-
-Let’s consider our `quarterly_expenditure_forecaster` model. We train the model using data until the third quarter of 2017, and the predictions come for the fourth quarter of 2017 (as defined by `horizon: 3`).
-
-## StatsForecast + HierarchicalForecast
-
-The StatsForecast handler also supports hierarchical reconciliation via Nixtla’s [HierarchicalForecast package](https://nixtla.github.io/hierarchicalforecast/). Hierarchical reconciliation may improve prediction accuracy when the data has a hierarchical structure.
-
-In this example, there may be a hierarchy as total expenditure is comprised of 7 different categories.
-
-```sql
-SELECT DISTINCT category
-FROM mysql_demo_db.historical_expenditures;
-```
-
-Here are the available categories:
-
-```sql
-+-------------------+
-| category          |
-+-------------------+
-| food              |
-| household_goods   |
-| clothing          |
-| department_stores |
-| other             |
-| cafes             |
-| industry          |
-+-------------------+
-```
-
-Spending in each category may be related over time. For example, if spending on `food` rises in October 2017, it may be more likely that spending on `cafes` also rises in October 2017. Hierarchical reconciliation can account for this shared information.
-
-Here is how we can create a model:
-
-```sql
-CREATE MODEL hierarchical_expenditure_forecaster
-FROM mysql_demo_db
-  (SELECT * FROM historical_expenditures)
-PREDICT expenditure
-GROUP BY category
-ORDER BY month
-HORIZON 3
-USING
-  ENGINE = 'statsforecast',
-  HIERARCHY = [‘category’];
-```
-
-The `CREATE MODEL` statement creates, trains, and deploys the model. Here, we predict the `expenditure` column values. As it is a time series model, we order the data by the `month` column. Additionally, we group data by the `category` column - the predictions are made for each group independently (here, for each category). The `HORIZON` clause defines for how many rows the predictions are made (here, for the next 3 rows).
-
-You can use the `DESCRIBE [MODEL]` command to check for details:
-
-```sql
-DESCRIBE hierarchical_expenditure_forecaster.model;
-```
-
-On execution, we get:
-
-```sql
-+------------+-----------+---------------+--------------+
-| model_name | frequency | season_length | hierarchy    |
-+------------+-----------+---------------+--------------+
-| AutoARIMA  | MS        | 1             | ["category"] |
-+------------+-----------+---------------+--------------+
-```
-
-Predictions with this model account for the hierarchical structure. The output may differ from the default model, which does not assume any hierarchy.
diff --git a/docs/integrations/ai-engines/timegpt.mdx b/docs/integrations/ai-engines/timegpt.mdx
deleted file mode 100644
index 4a0471066fa..00000000000
--- a/docs/integrations/ai-engines/timegpt.mdx
+++ /dev/null
@@ -1,120 +0,0 @@
----
-title: Nixtla's TimeGPT Integration with MindsDB
-sidebarTitle: TimeGPT
----
-
-TimeGPT by Nixtla is a generative pre-trained model specifically designed for predicting time series data. TimeGPT takes time series data as input and produces forecasted outputs. TimeGPT can be effectively employed in various applications, including demand forecasting, anomaly detection, financial prediction, and more.
-
-You can learn more about its features [here](https://nixtla.github.io/nixtla/).
-
-## How to bring TimeGPT Models to MindsDB
-
-Before creating a model, you will need to create an ML engine for TimeGPT using the `CREATE ML_ENGINE` statement and providing the TimeGPT API key:
-
-```sql
-CREATE ML_ENGINE timegpt
-FROM timegpt
-USING
-    timegpt_api_key = 'timegpt_api_key';
-```
-
-Once the ML engine is created, we use the `CREATE MODEL` statement to create the TimeGPT model in MindsDB.
-
-```sql
-CREATE MODEL model_name
-FROM data_source
-  (SELECT * FROM table_name)
-PREDICT column_to_be_predicted
-GROUP BY column_name, column_name, ...
-ORDER BY date_column
-HORIZON 3 -- model forecasts the next 3 rows
-USING ENGINE = 'timegpt';
-```
-
-To ensure that the model is created based on the TimeGPT engine, include the `USING` clause at the end, which defines the `engine` and lists all parameters used with time-series models, including `GROUP BY`, `ORDER BY`, `HORIZON`.
-
-What's different about the TimeGPT engine is that it does not expose the `WINDOW` parameter in its API, so as a user you need to send a payload with at least N rows, where N depends on the model and the frequency of the series. This is automatically handled by MindsDB in the [TimeGPT handler code](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/timegpt_handler).
-
-## Example
-
-Nixtla's TimeGPT model can be used to obtain real-time forecasts of the trading data from Binance.
-
-<Tip>
-Follow [this link](https://www.youtube.com/watch?v=8LfpFocdyEo&list=PLq3sJIV6w5BoHJ9gFSedwtb_pqk--4K89&index=3) to watch a video on integrating TimeGPT model with Binance data.
-</Tip>
-
-First, connect to Binance from MindsDB executing this command:
-
-```sql
-CREATE DATABASE my_binance
-WITH ENGINE = 'binance';
-```
-
-Please note that before using the TimeGPT engine, you should create it from the MindsDB editor, or other clients through which you interact with MindsDB, with the below command:
-
-```sql
-CREATE ML_ENGINE timegpt
-FROM timegpt
-USING
-    timegpt_api_key = 'timegpt_api_key';
-```
-
-You can check the available engines with this command:
-
-```sql
-SHOW ML_ENGINES;
-```
-
-If you see the TimeGPT engine on the list, you are ready to follow the tutorials.
-
-Now let's create a TimeGPT model and train it with data from Binance.
-
-```sql
-CREATE MODEL cryptocurrency_forecast_model
-FROM my_binance
-  (
-    SELECT *
-    FROM aggregated_trade_data
-    WHERE symbol = 'BTCUSDT'
-  )
-PREDICT open_price
-ORDER BY open_time
-HORIZON 10
-USING ENGINE = 'timegpt';
-```
-
-Use the `CREATE MODEL` statement to create, train, and deploy a model. The `FROM` clause defines the training data used to train the model - here, the latest Binance data is used. The `PREDICT` clause specifies the column to be predicted - here, the open price of the BTC/USDT trading pair is to be forecasted.
-
-As it is a time-series model, you should order the data by a date column - here, it is the open time when the open price takes effect. Finally, the `HORIZON` clause defines how many rows into the future the model will forecast - here, it forecasts the next 10 rows (the next 10 minutes, as the interval between Binance data rows is one minute).
-
-<Warning>
-Please note that the TimeGPT engine is sensitive to inconsistent intervals between data rows. Please check your data for missing, duplicated or irregular timestamps to mitigate errors that may arise if the intervals between data rows are inconsistent.
-
-In this example, the intervals between Binance data rows are consistently equal to one minute.
-</Warning>
-
-Before proceeding, make sure that the model status reads `complete`.
-
-```sql
-DESCRIBE cryptocurrency_forecast_model;
-```
-
-To make forecasts, you must save the Binance data into a view:
-
-```sql
-CREATE VIEW btcusdt_recent AS (
-  SELECT *
-  FROM my_binance.aggregated_trade_data
-  WHERE symbol = 'BTCUSDT'
-);
-```
-
-This view is going to be joined with the model to get forecasts:
-
-```sql
-SELECT m.open_time ,
-       m.open_price
-FROM btcusdt_recent AS d
-JOIN cryptocurrency_forecast_model AS m
-WHERE d.open_time > LATEST;
-```
diff --git a/docs/integrations/app-integrations/binance.mdx b/docs/integrations/app-integrations/binance.mdx
index 6e622db5c3e..596e8a32531 100644
--- a/docs/integrations/app-integrations/binance.mdx
+++ b/docs/integrations/app-integrations/binance.mdx
@@ -69,51 +69,3 @@ LIMIT 10000;
 <Note>
 Supported intervals are [listed here](https://binance-docs.github.io/apidocs/spot/en/#kline-candlestick-data)
 </Note>
-
-### Train a Model
-
-Here is how to create a time series model using 10000 trading intervals in the past with a duration of 1m.
-
-```sql
-CREATE MODEL mindsdb.btc_forecast_model
-FROM my_binance
-(
-  SELECT * FROM aggregated_trade_data
-  WHERE symbol = 'BTCUSDT'
-  AND close_time < '2023-01-01'
-  AND interval = '1m'
-  LIMIT 10000;
-)
-
-PREDICT open_price
-
-ORDER BY open_time
-WINDOW 100
-HORIZON 10;
-```
-
-<Note>
-For more accuracy, the limit can be set to a higher value (e.g. 100,000)
-</Note>
-
-### Making Predictions
-
-First, let's create a view for the most recent BTCUSDT aggregate trade data:
-
-```sql
-CREATE VIEW recent_btcusdt_data AS (
-  SELECT * FROM my_binance.aggregated_trade_data
-  WHERE symbol = 'BTCUSDT'
-)
-```
-
-Now let's predict the future price of BTC:
-
-```sql
-SELECT m.*
-FROM recent_btcusdt_data AS t
-JOIN mindsdb.btc_forecast_model AS m
-WHERE m.open_time > LATEST
-```
-
-This will give the predicted BTC price for the next 10 minutes (as the horizon is set to 10) in terms of USDT.
diff --git a/docs/integrations/app-integrations/instatus.mdx b/docs/integrations/app-integrations/instatus.mdx
index 93624974bd7..65f97e68fc1 100644
--- a/docs/integrations/app-integrations/instatus.mdx
+++ b/docs/integrations/app-integrations/instatus.mdx
@@ -41,7 +41,7 @@ To create a new status page, use the `INSERT` statement:
 
 ```sql
 INSERT INTO mindsdb_instatus.status_pages (email, name, subdomain, components, logoUrl, faviconUrl, websiteUrl, language, useLargeHeader, brandColor, okColor, disruptedColor, degradedColor, downColor, noticeColor, unknownColor, googleAnalytics, subscribeBySms, smsService, twilioSid, twilioToken, twilioSender, nexmoKey, nexmoSecret, nexmoSender, htmlInMeta, htmlAboveHeader, htmlBelowHeader, htmlAboveFooter, htmlBelowFooter, htmlBelowSummary, cssGlobal, launchDate, dateFormat, dateFormatShort, timeFormat)
-VALUES ('yourname@gmail.com', 'mindsdb', 'mindsdb-instatus', '["Website", "App", "API"]', 'https://instatus.com/sample.png', 'https://instatus.com/favicon-32x32.png', 'https://instatus.com', 'en', true, '#111', '#33B17E', '#FF8C03', '#ECC94B', '#DC123D', '#70808F', '#DFE0E1', 'UA-00000000-1', true, 'twilio', 'YOUR_TWILIO_SID', 'YOUR_TWILIO_TOKEN', 'YOUR_TWILIO_SENDER', null, null, null, null, null, null, null, null, null, null, 'MMMMMM d, yyyy', 'MMM yyyy', 'p');
+VALUES ('yourname@gmail.com', 'mindsdb', 'mindsdb-instatus', '["Website", "App", "API"]', 'https://instatus.com/sample.png', 'https://instatus.com/favicon-32x32.png', 'https://instatus.com', 'en', 'true', '#111', '#33B17E', '#FF8C03', '#ECC94B', '#DC123D', '#70808F', '#DFE0E1', 'UA-00000000-1', 'true', 'twilio', 'YOUR_TWILIO_SID', 'YOUR_TWILIO_TOKEN', 'YOUR_TWILIO_SENDER', null, null, null, null, null, null, null, null, null, null, null, 'MMMMMM d, yyyy', 'MMM yyyy', 'p');
 ```
 
 <Tip>
diff --git a/docs/integrations/app-integrations/jira.mdx b/docs/integrations/app-integrations/jira.mdx
index f4a3e8a4a42..3671aa31af4 100644
--- a/docs/integrations/app-integrations/jira.mdx
+++ b/docs/integrations/app-integrations/jira.mdx
@@ -22,18 +22,23 @@ CREATE DATABASE jira_datasource
 WITH
     ENGINE = 'jira',
     PARAMETERS = {
-        "url": "https://example.atlassian.net",
-        "username": "john.doe@example.com",
-        "api_token": "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
+        "jira_url": "https://example.atlassian.net",
+        "jira_username": "john.doe@example.com",
+        "jira_api_token": "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6",
+        "cloud": true
     };
 ```
 
 Required connection parameters include the following:
 
-* `url`: The base URL for your Jira instance/server.
-* `username`: The email address associated with your Jira account.
-* `api_token`: The API token generated for your Jira account.
-* `cloud`: (Optional) Set to `true` for Jira Cloud or `false` for Jira Server. Defaults to `true`.
+- `jira_url`: The base URL for your Jira instance/server.
+- `cloud` (optional): Set `true` for Jira Cloud or `false` for Jira Server. Defaults to `true`.
+- Jira Cloud credentials:
+  - `jira_username`
+  - `jira_api_token`
+- Jira Server credentials (set `cloud: false`):
+  - Either `jira_personal_access_token`, **or**
+  - `jira_username` and `jira_password`
 
 <Tip>
 Refer this [guide](https://support.atlassian.com/atlassian-account/docs/manage-api-tokens-for-your-atlassian-account/) for instructions on how to create API tokens for your account.
@@ -51,4 +56,45 @@ LIMIT 10;
 
 <Note>
 The above example utilize `jira_datasource` as the datasource name, which is defined in the `CREATE DATABASE` command.
-</Note>
\ No newline at end of file
+</Note>
+
+## Available tables
+
+The handler registers the following tables:
+
+- `projects`: Basic project metadata.
+- `issues`: Normalized issue fields (project, summary, description, priority, status, labels, components, creator/reporter/assignee, timestamps).
+- `attachments`: Attachments derived from issues.
+- `comments`: Comments derived from issues.
+- `users`: Users available to the current Jira context. Column set depends on `cloud`:
+  - Cloud columns: `accountId, accountType, emailAddress, displayName, active, timeZone, locale, applicationRoles, avatarUrls, groups`
+  - Server columns: `key, name, emailAddress, displayName, active, timeZone, locale, lastLoginTime, applicationRoles, avatarUrls, groups, deleted, expand`
+- `groups`: User groups (`groupId, name, html`).
+
+Attachments and comments are fetched by first loading issues. Use `LIMIT` whenever possible to reduce API calls.
+
+## Query examples
+
+List projects:
+
+```sql
+SELECT id, key, name
+FROM jira_datasource.projects;
+```
+
+Fetch recent issues for a project:
+
+```sql
+SELECT key, summary, status, assignee, created
+FROM jira_datasource.issues
+WHERE project_key = 'ENG'
+LIMIT 50;
+```
+
+Retrieve comments for a specific issue:
+
+```sql
+SELECT body, author, created
+FROM jira_datasource.comments
+WHERE issue_key = 'ENG-123';
+```
diff --git a/docs/integrations/app-integrations/strapi.mdx b/docs/integrations/app-integrations/strapi.mdx
index cdb66e063e4..e92d560d632 100644
--- a/docs/integrations/app-integrations/strapi.mdx
+++ b/docs/integrations/app-integrations/strapi.mdx
@@ -14,7 +14,7 @@ To use the Strapi Handler, initialize it with the following parameters:
 - `host`: Strapi server host.
 - `port`: Strapi server port (typically 1337).
 - `api_token`: Strapi server API token for authentication.
-- `plural_api_ids`: List of plural API IDs for the collections.
+- `endpoints`: List of collection endpoints.
 
 To get started, create a Strapi engine database with the following SQL command:
 
@@ -25,7 +25,7 @@ PARAMETERS = {
   "host" : "<strapi-host>", --- Host (can be an IP address or URL).
   "port" : "<strapi-port>",  --- Common port is 1337.
   "api_token": "<your-strapi-api-token>", --- API token of the Strapi server.
-  "plural_api_ids" : ["<plural-api-id>"] --- Plural API IDs of the collections.
+  "endpoints" : ["<collection-endpoint>"] --- Collection endpoints.
 };
 ```
 
@@ -43,7 +43,7 @@ Filter data based on specific criteria:
 ```sql
 SELECT *
 FROM myshop.<collection-name>
-WHERE id = <id-value>
+WHERE documentId = '<documentId-value>';
 ```
 
 Insert new data into a collection:
@@ -64,7 +64,7 @@ Modify existing data in a collection:
 ```sql
 UPDATE myshop.<collection-name>
 SET <field-name-1> = <value-1>, <field-name-2> = <value-2>, ...
-WHERE id = <id-value>;
+WHERE documentId = '<documentId-value>';
 ```
 
 <Tip>
diff --git a/docs/integrations/support.mdx b/docs/integrations/support.mdx
index 4f52b81fdf3..d76df9af518 100644
--- a/docs/integrations/support.mdx
+++ b/docs/integrations/support.mdx
@@ -51,7 +51,6 @@ Below is the list of all community integrations.
 | Llama Index | AI | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/llama_index_handler) |
 | Anthropic | AI | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/anthropic_handler) |
 | MariaDB | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/mariadb_handler) |
-| TimeGPT | AI | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/timegpt_handler) |
 | X (Twitter) | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/twitter_handler) |
 | GitHub | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/github_handler) |
 | Hugging Face Inference API | AI | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/huggingface_api_handler) |
@@ -61,7 +60,6 @@ Below is the list of all community integrations.
 | Confluence | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/confluence_handler) |
 | Gmail | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/gmail_handler) |
 | Couchbase | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/couchbase_handler) |
-| StatsForecast | AI | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/statsforecast_handler) |
 | Twelve Labs | AI | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/twelve_labs_handler) |
 | Anomaly Detection | AI | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/anomaly_detection_handler) |
 | YouTube | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/youtube_handler) |
@@ -147,7 +145,6 @@ Below is the list of all community integrations.
 | MonetDB | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/monetdb_handler) |
 | MonkeyLearn | AI | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/monkeylearn_handler) |
 | Microsoft Teams | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/ms_teams_handler) |
-| NeuralForecast | AI | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/neuralforecast_handler) |
 | NewsAPI | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/newsapi_handler) |
 | Notion | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/notion_handler) |
 | npm | DATA | [Link](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/npm_handler) |
diff --git a/docs/mindsdb-handlers.mdx b/docs/mindsdb-handlers.mdx
index c69e09cee4c..0d9a1aaac36 100644
--- a/docs/mindsdb-handlers.mdx
+++ b/docs/mindsdb-handlers.mdx
@@ -76,7 +76,7 @@ Whenever you want to parse a string that contains SQL, we strongly recommend usi
 
 ### Formatting Output
 
-In the case of data handlers, when it comes to building the response of the public methods, the output should be wrapped by the [mindsdb.integrations.libs.response.HandlerResponse](https://github.com/mindsdb/mindsdb/blob/main/mindsdb/integrations/libs/response.py#L7) or [mindsdb.integrations.libs.response.HandlerStatusResponse](https://github.com/mindsdb/mindsdb/blob/main/mindsdb/integrations/libs/response.py#L32) class. These classes are used by the MindsDB executioner to orchestrate and coordinate multiple handler instances in parallel.
+In the case of data handlers, the data-returning methods (`native_query()`, `query()`, `get_tables()`, `get_columns()`) should return one of the response classes from [mindsdb.integrations.libs.response](https://github.com/mindsdb/mindsdb/blob/main/mindsdb/integrations/libs/response.py)
 
 And in the case of ML handlers, output wrapping is automatically done by an intermediate wrapper, the `BaseMLEngineExec` class, so the contributor wouldn't need to worry about it.
 
diff --git a/docs/mindsdb_sql/agents/agent_syntax.mdx b/docs/mindsdb_sql/agents/agent_syntax.mdx
index 9c1d3c01563..42597689170 100644
--- a/docs/mindsdb_sql/agents/agent_syntax.mdx
+++ b/docs/mindsdb_sql/agents/agent_syntax.mdx
@@ -24,7 +24,8 @@ USING
          "tables": ["datasource_conn_name.table_name", ...]
     },
     prompt_template='describe data',
-    timeout=10;
+    timeout=10,
+    mode='text';
 ```
 
 It creates an agent that uses the defined model and has access to the connected data.
@@ -315,6 +316,12 @@ This parameter defines the time the agent can take to come back with an answer.
 
 For example, when the `timeout` parameter is set to 10, the agent has 10 seconds to return an answer. If the agent takes longer than 10 seconds, it aborts the process and comes back with an answer indicating its failure to return an answer within the defined time interval.
 
+### `mode`
+
+This parameter defines the agent's response style, allowing users to partially control the output format. Supported values include `text` and `sql`.
+
+When set, the agent will tailor its responses to match the specified format. Note that the agent may still adapt its output when necessary to ensure clarity or correctness.
+
 ## `SELECT FROM AGENT` Syntax
 
 Query an agent to generate responses to questions.
diff --git a/docs/mindsdb_sql/sql/create/ml-engine.mdx b/docs/mindsdb_sql/sql/create/ml-engine.mdx
index 1e10bba6c63..ece54f7916e 100644
--- a/docs/mindsdb_sql/sql/create/ml-engine.mdx
+++ b/docs/mindsdb_sql/sql/create/ml-engine.mdx
@@ -70,14 +70,12 @@ On execution, we get:
 | NAME              | TITLE              | DESCRIPTION                                           | VERSION | CONNECTION_ARGS                                                                                                                                     | IMPORT_SUCCESS | IMPORT_ERROR                                                                |
 +-------------------+--------------------+-------------------------------------------------------+---------+-----------------------------------------------------------------------------------------------------------------------------------------------------+----------------+-----------------------------------------------------------------------------+
 | "ray_serve"       | "RayServe"         | "MindsDB handler for Ray Serve"                       | "0.0.1" | "[NULL]"                                                                                                                                            | "true"         | "[NULL]"                                                                    |
-| "neuralforecast"  | "NeuralForecast"   | "MindsDB handler for Nixtla's NeuralForecast package" | "0.0.1" | "[NULL]"                                                                                                                                            | "true"         | "[NULL]"                                                                    |
 | "autosklearn"     | "Auto-Sklearn"     | "MindsDB handler for Auto-Sklearn"                    | "0.0.2" | "[NULL]"                                                                                                                                            | "false"        | "No module named 'autosklearn'"                                             |
 | "mlflow"          | "MLFlow"           | "MindsDB handler for MLflow"                          | "0.0.2" | "[NULL]"                                                                                                                                            | "false"        | "No module named 'mlflow'"                                                  |
 | "openai"          | "OpenAI"           | "MindsDB handler for OpenAI"                          | "0.0.1" | "[NULL]"                                                                                                                                            | "true"         | "[NULL]"                                                                    |
 | "merlion"         | "Merlion"          | "MindsDB handler for Merlion"                         | "0.0.1" | "[NULL]"                                                                                                                                            | "false"        | "object.__init__() takes exactly one argument (the instance to initialize)" |
 | "byom"            | "BYOM"             | "MindsDB handler for BYOM"                            | "0.0.1" | "{'code': {'type': 'path', 'description': 'The path to model code'}, 'modules': {'type': 'path', 'description': 'The path to model requirements'}}" | "true"         | "[NULL]"                                                                    |
 | "huggingface_api" | "Hugging Face API" | "MindsDB handler for Auto-Sklearn"                    | "0.0.2" | "[NULL]"                                                                                                                                            | "false"        | "No module named 'hugging_py_face'"                                         |
-| "statsforecast"   | "StatsForecast"    | "MindsDB handler for Nixtla's StatsForecast package"  | "0.0.0" | "[NULL]"                                                                                                                                            | "true"         | "[NULL]"                                                                    |
 | "huggingface"     | "Hugging Face"     | "MindsDB handler for Higging Face"                    | "0.0.1" | "[NULL]"                                                                                                                                            | "true"         | "[NULL]"                                                                    |
 | "TPOT"            | "Tpot"             | "MindsDB handler for TPOT "                           | "0.0.2" | "[NULL]"                                                                                                                                            | "false"        | "No module named 'tpot'"                                                    |
 | "langchain"       | "LangChain"        | "MindsDB handler for LangChain"                       | "0.0.1" | "[NULL]"                                                                                                                                            | "true"         | "[NULL]"                                                                    |
diff --git a/docs/mindsdb_sql/sql/create/model.mdx b/docs/mindsdb_sql/sql/create/model.mdx
index 3fa60ccfe3c..a68ed13da10 100644
--- a/docs/mindsdb_sql/sql/create/model.mdx
+++ b/docs/mindsdb_sql/sql/create/model.mdx
@@ -8,8 +8,8 @@ sidebarTitle: Create, Train, and Deploy a Model
 The `CREATE MODEL` statement creates and trains a machine learning (ML) model.
 
 <Info>
-    Please note that the `CREATE MODEL` statement is equivalent to the `CREATE MODEL` statement.
-    We are transitioning to the `CREATE MODEL` statement, but the `CREATE MODEL` statement still works.
+    Please note that the `CREATE PREDICTOR` statement is equivalent to the `CREATE MODEL` statement.
+    We are transitioning to the `CREATE MODEL` statement, but the `CREATE PREDICTOR` statement still works.
 </Info>
 
 ## Syntax
diff --git a/docs/model-context-protocol/anthropic.mdx b/docs/model-context-protocol/anthropic.mdx
index ba8609f5b23..0b594db756a 100644
--- a/docs/model-context-protocol/anthropic.mdx
+++ b/docs/model-context-protocol/anthropic.mdx
@@ -35,7 +35,7 @@ response = client.beta.messages.create(
     mcp_servers = [
         {
             "type": "url",
-            "url": "https://5a52-88-203-84-191.ngrok-free.app/mcp/sse",
+            "url": "https://<your-ngrok-url>/mcp/sse",
             "name": "mindsdb-mcp",
             "authorization_token": "<YOUR_MINDSDB_TOKEN>"
         }
diff --git a/docs/model-context-protocol/openai.mdx b/docs/model-context-protocol/openai.mdx
index c3d8ea2df54..3d9736dde9e 100644
--- a/docs/model-context-protocol/openai.mdx
+++ b/docs/model-context-protocol/openai.mdx
@@ -32,7 +32,7 @@ response = client.responses.create(
         {
             "type": "mcp",
             "server_label": "mdb",
-            "server_url": "https://5a52-88-203-84-191.ngrok-free.app/mcp/sse",
+            "server_url": "https://<your-ngrok-url>/mcp/sse",
             "headers": { "Authorization": "Bearer <YOUR_MINDSDB_TOKEN>" },
             "require_approval": "never",
         }
diff --git a/docs/model-context-protocol/usage.mdx b/docs/model-context-protocol/usage.mdx
index 5f18ac91937..43ed653b8d8 100644
--- a/docs/model-context-protocol/usage.mdx
+++ b/docs/model-context-protocol/usage.mdx
@@ -29,37 +29,67 @@ Follow the steps below to use MindsDB as an MCP server.
     ```
     </Accordion>
 
-3. Start MindsDB MCP server, either with or without authentication.
+3. Start MindsDB MCP server.
 
-    * Start MindsDB MCP server without authentication to connect it to [Cursor](/mcp/cursor_usage).
+    * **Without authentication** (suitable for local tools):
 
         ```bash
-        docker run --name mindsdb_container -p 47334:47334 -p 47335:47335 mindsdb/mindsdb
+        docker run --name mindsdb_container -p 47334:47334 mindsdb/mindsdb
         ```
 
-    * Start MindsDB MCP server with authentication to connect it to [OpenAI](/mcp/openai) or [Anthropic](/mcp/anthropic).
+    * **With PAT authentication** (suitable for remote):
 
         ```bash
-        docker run --name mindsdb_container -p 47334:47334 -p 47335:47335 -e MINDSDB_USERNAME=admin -e MINDSDB_PASSWORD=password123 mindsdb/mindsdb
+        docker run --name mindsdb_container -p 47334:47334 -e MINDSDB_USERNAME=admin -e MINDSDB_PASSWORD=password123 mindsdb/mindsdb
         ```
 
-        Then get an auth token from MindsDB:
+        Get a Bearer token:
         ```bash
         curl -X POST -d '{"username":"admin","password":"password123"}' -H "Content-Type: application/json" http://localhost:47334/api/login
         ```
-        This will return a token that you can use in your MCP client.
+        Use this token as `Authorization: Bearer <token>` in your MCP client.
+
+    * **With OAuth 2.0** (for enterprise deployments): configure `MINDSDB_MCP_OAUTH_ENABLED=true` along with `MINDSDB_MCP_OAUTH_ISSUER_URL`, `MINDSDB_MCP_OAUTH_CLIENT_ID`, and `MINDSDB_MCP_OAUTH_CLIENT_SECRET`.
 
 4. To confirm the MindsDB MCP server is running use `http://127.0.0.1:47334/mcp/status`. A successful response means your MCP environment is ready.
 
 
-## MCP Tools
+## MCP Capabilities
+
+### Tools
+
+**`query`** — Executes SQL queries against MindsDB using MySQL syntax.
+
+Parameters:
+- `query` (required): SQL query string
+- `context` (optional): Dict with default database, e.g. `{"db": "my_postgres"}`
+
+Returns one of:
+- `{"type": "table", "column_names": [...], "data": [...]}` — for SELECT results
+- `{"type": "ok", "affected_rows": N}` — for INSERT/UPDATE/DELETE
+- `{"type": "error", "error_code": N, "error_message": "..."}` — on failure
+
+### Resources
+
+MCP resources expose schema information for discovery:
+
+| Resource URI | Description |
+|---|---|
+| `schema://databases` | Lists all connected data sources |
+| `schema://databases/{db}/tables` | Lists tables in a database |
+| `schema://databases/{db}/tables/{table}/columns` | Lists columns with types |
+| `schema://knowledge_bases` | Lists knowledge bases |
+
+### Prompts
 
-MindsDB MCP API exposes a set of tools that enable users to interact with their data and extract valuable insights.
+**`sample_table`** — Generates instructions to fetch 5 sample rows and describe a table's structure.
 
-**1. List Databases**
+## Transport Modes
 
-The `list_databases` tool lists all data sources connected to MindsDB.
+- **HTTP (SSE)**: `http://127.0.0.1:47334/mcp/sse`
+- **HTTP (Streamable)**: `http://127.0.0.1:47334/mcp/streamable`
+- **Stdio**: run with `--mcp-stdio` flag for local stdio-based transport
 
-**2. Query**
+## Configuration
 
-The `query` tool executes queries on the federated data to extract data relevant to answering a given question.
+CORS, rate limiting, DNS rebinding protection, and OAuth settings for the MCP server are configured via the `api.mcp` section of `config.json` or the corresponding environment variables. See [Extend the Default MindsDB Configuration](/setup/custom-config#mcp-api) for the full parameter reference.
diff --git a/docs/package-lock.json b/docs/package-lock.json
index 035fed79a8a..34c7e58ecd5 100644
--- a/docs/package-lock.json
+++ b/docs/package-lock.json
@@ -5,7 +5,7 @@
   "packages": {
     "": {
       "dependencies": {
-        "mintlify": "^4.2.408",
+        "mintlify": "^4.2.500",
         "sharp": "^0.34.4"
       }
     },
@@ -115,9 +115,9 @@
       "license": "MIT"
     },
     "node_modules/@emnapi/runtime": {
-      "version": "1.7.1",
-      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.7.1.tgz",
-      "integrity": "sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==",
+      "version": "1.9.2",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.9.2.tgz",
+      "integrity": "sha512-3U4+MIWHImeyu1wnmVygh5WlgfYDtyf0k8AbLhMFxOipihf6nrWC4syIm/SwEeec0mNSafiiNnMJwbza/Is6Lw==",
       "license": "MIT",
       "optional": true,
       "dependencies": {
@@ -160,9 +160,9 @@
       "peer": true
     },
     "node_modules/@img/colour": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.0.0.tgz",
-      "integrity": "sha512-A5P/LfWGFSl6nsckYtjw9da+19jB8hkJ6ACTGcDfEJ0aE+l2n2El7dsVM7UVHZQ9s2lmYMWlrS21YLy2IR1LUw==",
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.1.0.tgz",
+      "integrity": "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==",
       "license": "MIT",
       "engines": {
         "node": ">=18"
@@ -251,6 +251,9 @@
       "cpu": [
         "arm"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -267,6 +270,9 @@
       "cpu": [
         "arm64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -283,6 +289,9 @@
       "cpu": [
         "ppc64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -299,6 +308,9 @@
       "cpu": [
         "riscv64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -315,6 +327,9 @@
       "cpu": [
         "s390x"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -331,6 +346,9 @@
       "cpu": [
         "x64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -347,6 +365,9 @@
       "cpu": [
         "arm64"
       ],
+      "libc": [
+        "musl"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -363,6 +384,9 @@
       "cpu": [
         "x64"
       ],
+      "libc": [
+        "musl"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -379,6 +403,9 @@
       "cpu": [
         "arm"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -401,6 +428,9 @@
       "cpu": [
         "arm64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -423,6 +453,9 @@
       "cpu": [
         "ppc64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -445,6 +478,9 @@
       "cpu": [
         "riscv64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -467,6 +503,9 @@
       "cpu": [
         "s390x"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -489,6 +528,9 @@
       "cpu": [
         "x64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -511,6 +553,9 @@
       "cpu": [
         "arm64"
       ],
+      "libc": [
+        "musl"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -533,6 +578,9 @@
       "cpu": [
         "x64"
       ],
+      "libc": [
+        "musl"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1090,19 +1138,17 @@
       }
     },
     "node_modules/@mintlify/cli": {
-      "version": "4.0.1011",
-      "resolved": "https://registry.npmjs.org/@mintlify/cli/-/cli-4.0.1011.tgz",
-      "integrity": "sha512-olPH+gr8WYElRGc57MsBcLViOlSPmeCM1/YPF2kjwFKnycuKQUhZiCAwGHRXEvpaCUQ70XnOtF2uDMs831krlg==",
+      "version": "4.0.1103",
+      "resolved": "https://registry.npmjs.org/@mintlify/cli/-/cli-4.0.1103.tgz",
+      "integrity": "sha512-/Tz4ydJp0eY4I5oKv4D4FYK0xPm9fpwCfnSye4UzjRU7bVUv34Qzi6px/1PQJbQtpUiISwF7tuWH6tyB5AWknw==",
       "license": "Elastic-2.0",
       "dependencies": {
         "@inquirer/prompts": "7.9.0",
-        "@mintlify/common": "1.0.779",
-        "@mintlify/link-rot": "3.0.946",
-        "@mintlify/models": "0.0.283",
-        "@mintlify/prebuild": "1.0.917",
-        "@mintlify/previewing": "4.0.975",
-        "@mintlify/scraping": "4.0.641",
-        "@mintlify/validation": "0.1.626",
+        "@mintlify/common": "1.0.844",
+        "@mintlify/link-rot": "3.0.1019",
+        "@mintlify/prebuild": "1.0.986",
+        "@mintlify/previewing": "4.0.1047",
+        "@mintlify/validation": "0.1.660",
         "adm-zip": "0.5.16",
         "chalk": "5.2.0",
         "color": "4.2.3",
@@ -1113,10 +1159,14 @@
         "inquirer": "12.3.0",
         "js-yaml": "4.1.0",
         "mdast-util-mdx-jsx": "3.2.0",
+        "open": "^8.4.2",
+        "openid-client": "^6.8.2",
+        "posthog-node": "5.17.2",
         "react": "19.2.3",
         "semver": "7.7.2",
         "unist-util-visit": "5.0.0",
-        "yargs": "17.7.1"
+        "yargs": "17.7.1",
+        "zod": "^4.3.6"
       },
       "bin": {
         "mint": "bin/index.js",
@@ -1124,20 +1174,23 @@
       },
       "engines": {
         "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "keytar": "^7.9.0"
       }
     },
     "node_modules/@mintlify/common": {
-      "version": "1.0.779",
-      "resolved": "https://registry.npmjs.org/@mintlify/common/-/common-1.0.779.tgz",
-      "integrity": "sha512-L/LTFNDrS6t7ADymvG6o8zIlLnSjcmEfwBJHBCG99EjynumJBHD2Im/WKNtjWHg1ilED7oOZM4F9iASKP6Flkw==",
+      "version": "1.0.844",
+      "resolved": "https://registry.npmjs.org/@mintlify/common/-/common-1.0.844.tgz",
+      "integrity": "sha512-uTQ5yGFNvP4wpc5FHvBEkJubg5VNW9R2LL9+IcSg/KraDzRn0vCD9YIdq2f2RdwYDYl6sWGMmYjDxUqrOOZVFg==",
       "license": "ISC",
       "dependencies": {
         "@asyncapi/parser": "3.4.0",
         "@asyncapi/specs": "6.8.1",
         "@mintlify/mdx": "^3.0.4",
-        "@mintlify/models": "0.0.283",
+        "@mintlify/models": "0.0.290",
         "@mintlify/openapi-parser": "^0.0.8",
-        "@mintlify/validation": "0.1.626",
+        "@mintlify/validation": "0.1.660",
         "@sindresorhus/slugify": "2.2.0",
         "@types/mdast": "4.0.4",
         "acorn": "8.11.2",
@@ -1172,7 +1225,7 @@
         "remark-rehype": "11.1.1",
         "remark-stringify": "11.0.0",
         "sucrase": "^3.34.0",
-        "tailwindcss": "3.4.4",
+        "tailwindcss": "^3.4.17",
         "unified": "11.0.5",
         "unist-builder": "4.0.0",
         "unist-util-map": "4.0.0",
@@ -1518,15 +1571,15 @@
       }
     },
     "node_modules/@mintlify/common/node_modules/next-mdx-remote-client": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/next-mdx-remote-client/-/next-mdx-remote-client-1.1.6.tgz",
-      "integrity": "sha512-O4HIpi44d6SismhfG5W78aTUfgxfbsj6FgoM4/G3o4Vtcobt0Ej439IiDPkv+IqsmtouVYG1tGAsz1DIuj9Tfg==",
+      "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/next-mdx-remote-client/-/next-mdx-remote-client-1.1.7.tgz",
+      "integrity": "sha512-12Ap5Z/tFIETMXFSBTH2IFEhJAso7MvOJ5ICyesA4q6FM4vtAcmb+4ZKa4tV1IVQJLBVqOhaEfIESZzdwjmrQQ==",
       "license": "MPL 2.0",
       "dependencies": {
         "@babel/code-frame": "^7.29.0",
         "@mdx-js/mdx": "^3.1.1",
         "@mdx-js/react": "^3.1.1",
-        "remark-mdx-remove-esm": "^1.2.3",
+        "remark-mdx-remove-esm": "^1.3.1",
         "serialize-error": "^13.0.1",
         "vfile": "^6.0.3",
         "vfile-matter": "^5.0.1"
@@ -1577,16 +1630,16 @@
       }
     },
     "node_modules/@mintlify/link-rot": {
-      "version": "3.0.946",
-      "resolved": "https://registry.npmjs.org/@mintlify/link-rot/-/link-rot-3.0.946.tgz",
-      "integrity": "sha512-6+5l1NsHlwovfcKKZR8R7K0poWPKP0DU7viSd+fpV4PgxH+H0MsfLRpIft89laWw4MaDYI4Ghz2CzchWL5ozCg==",
+      "version": "3.0.1019",
+      "resolved": "https://registry.npmjs.org/@mintlify/link-rot/-/link-rot-3.0.1019.tgz",
+      "integrity": "sha512-moUkUUcdfm/ivgavmrcgcnxhJ4XCDAbYPABhQbwo6hP3FHXyTB8jJdbjG/wJLZSzjH3KQpq/+DglMH5cCmSNJQ==",
       "license": "Elastic-2.0",
       "dependencies": {
-        "@mintlify/common": "1.0.779",
-        "@mintlify/prebuild": "1.0.917",
-        "@mintlify/previewing": "4.0.975",
+        "@mintlify/common": "1.0.844",
+        "@mintlify/prebuild": "1.0.986",
+        "@mintlify/previewing": "4.0.1047",
         "@mintlify/scraping": "4.0.522",
-        "@mintlify/validation": "0.1.626",
+        "@mintlify/validation": "0.1.660",
         "fs-extra": "11.1.0",
         "unist-util-visit": "4.1.2"
       },
@@ -1594,517 +1647,607 @@
         "node": ">=18.0.0"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@floating-ui/react-dom": {
-      "version": "2.1.8",
-      "resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.8.tgz",
-      "integrity": "sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A==",
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@floating-ui/dom": "^1.7.6"
-      },
-      "peerDependencies": {
-        "react": ">=16.8.0",
-        "react-dom": ">=16.8.0"
-      }
+    "node_modules/@mintlify/link-rot/node_modules/@types/unist": {
+      "version": "2.0.11",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
+      "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
+      "license": "MIT"
     },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/mdx": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@mintlify/mdx/-/mdx-3.0.4.tgz",
-      "integrity": "sha512-tJhdpnM5ReJLNJ2fuDRIEr0zgVd6id7/oAIfs26V46QlygiLsc8qx4Rz3LWIX51rUXW/cfakjj0EATxIciIw+g==",
+    "node_modules/@mintlify/link-rot/node_modules/fs-extra": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.0.tgz",
+      "integrity": "sha512-0rcTq621PD5jM/e0a3EJoGC/1TC5ZBCERW82LQuwfGnCa1V8w7dpYH1yNu+SLb6E5dkeCBzKEyLGlFrnr+dUyw==",
       "license": "MIT",
       "dependencies": {
-        "@shikijs/transformers": "^3.11.0",
-        "@shikijs/twoslash": "^3.12.2",
-        "arktype": "^2.1.26",
-        "hast-util-to-string": "^3.0.1",
-        "mdast-util-from-markdown": "^2.0.2",
-        "mdast-util-gfm": "^3.1.0",
-        "mdast-util-mdx-jsx": "^3.2.0",
-        "mdast-util-to-hast": "^13.2.0",
-        "next-mdx-remote-client": "^1.0.3",
-        "rehype-katex": "^7.0.1",
-        "remark-gfm": "^4.0.0",
-        "remark-math": "^6.0.0",
-        "remark-smartypants": "^3.0.2",
-        "shiki": "^3.11.0",
-        "unified": "^11.0.0",
-        "unist-util-visit": "^5.0.0"
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
       },
-      "peerDependencies": {
-        "@radix-ui/react-popover": "^1.1.15",
-        "react": "^18.3.1",
-        "react-dom": "^18.3.1"
+      "engines": {
+        "node": ">=14.14"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/mdx/node_modules/mdast-util-gfm": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz",
-      "integrity": "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==",
+    "node_modules/@mintlify/link-rot/node_modules/unist-util-is": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz",
+      "integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==",
       "license": "MIT",
       "dependencies": {
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-gfm-autolink-literal": "^2.0.0",
-        "mdast-util-gfm-footnote": "^2.0.0",
-        "mdast-util-gfm-strikethrough": "^2.0.0",
-        "mdast-util-gfm-table": "^2.0.0",
-        "mdast-util-gfm-task-list-item": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0"
+        "@types/unist": "^2.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/mdx/node_modules/mdast-util-mdx-jsx": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz",
-      "integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==",
+    "node_modules/@mintlify/link-rot/node_modules/unist-util-visit": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz",
+      "integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==",
       "license": "MIT",
       "dependencies": {
-        "@types/estree-jsx": "^1.0.0",
-        "@types/hast": "^3.0.0",
-        "@types/mdast": "^4.0.0",
-        "@types/unist": "^3.0.0",
-        "ccount": "^2.0.0",
-        "devlop": "^1.1.0",
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0",
-        "parse-entities": "^4.0.0",
-        "stringify-entities": "^4.0.0",
-        "unist-util-stringify-position": "^4.0.0",
-        "vfile-message": "^4.0.0"
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0",
+        "unist-util-visit-parents": "^5.1.1"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/mdx/node_modules/unist-util-visit": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.1.0.tgz",
-      "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==",
+    "node_modules/@mintlify/link-rot/node_modules/unist-util-visit-parents": {
+      "version": "5.1.3",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz",
+      "integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==",
       "license": "MIT",
       "dependencies": {
-        "@types/unist": "^3.0.0",
-        "unist-util-is": "^6.0.0",
-        "unist-util-visit-parents": "^6.0.0"
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/models": {
-      "version": "0.0.255",
-      "resolved": "https://registry.npmjs.org/@mintlify/models/-/models-0.0.255.tgz",
-      "integrity": "sha512-LIUkfA7l7ypHAAuOW74ZJws/NwNRqlDRD/U466jarXvvSlGhJec/6J4/I+IEcBvWDnc9anLFKmnGO04jPKgAsg==",
+    "node_modules/@mintlify/models": {
+      "version": "0.0.290",
+      "resolved": "https://registry.npmjs.org/@mintlify/models/-/models-0.0.290.tgz",
+      "integrity": "sha512-dkUIepQOpyZmgdapL22wdQi7MXupLyqFWP/ebiP0NYLcRRYBLWFVcpHHfIDGC2mWOZxNCVVZDvg2rTzfccpj6A==",
       "license": "Elastic-2.0",
       "dependencies": {
-        "axios": "1.10.0",
+        "axios": "1.13.2",
         "openapi-types": "12.1.3"
       },
       "engines": {
         "node": ">=18.0.0"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/scraping": {
-      "version": "4.0.522",
-      "resolved": "https://registry.npmjs.org/@mintlify/scraping/-/scraping-4.0.522.tgz",
-      "integrity": "sha512-PL2k52WT5S5OAgnT2K13bP7J2El6XwiVvQlrLvxDYw5KMMV+y34YVJI8ZscKb4trjitWDgyK0UTq2KN6NQgn6g==",
-      "license": "Elastic-2.0",
+    "node_modules/@mintlify/openapi-parser": {
+      "version": "0.0.8",
+      "resolved": "https://registry.npmjs.org/@mintlify/openapi-parser/-/openapi-parser-0.0.8.tgz",
+      "integrity": "sha512-9MBRq9lS4l4HITYCrqCL7T61MOb20q9IdU7HWhqYMNMM1jGO1nHjXasFy61yZ8V6gMZyyKQARGVoZ0ZrYN48Og==",
+      "license": "MIT",
       "dependencies": {
-        "@mintlify/common": "1.0.661",
-        "@mintlify/openapi-parser": "^0.0.8",
-        "fs-extra": "11.1.1",
-        "hast-util-to-mdast": "10.1.0",
-        "js-yaml": "4.1.0",
-        "mdast-util-mdx-jsx": "3.1.3",
-        "neotraverse": "0.6.18",
-        "puppeteer": "22.14.0",
-        "rehype-parse": "9.0.1",
-        "remark-gfm": "4.0.0",
-        "remark-mdx": "3.0.1",
-        "remark-parse": "11.0.0",
-        "remark-stringify": "11.0.0",
-        "unified": "11.0.5",
-        "unist-util-visit": "5.0.0",
-        "yargs": "17.7.1",
-        "zod": "3.21.4"
-      },
-      "bin": {
-        "mintlify-scrape": "bin/cli.js"
+        "ajv": "^8.17.1",
+        "ajv-draft-04": "^1.0.0",
+        "ajv-formats": "^3.0.1",
+        "jsonpointer": "^5.0.1",
+        "leven": "^4.0.0",
+        "yaml": "^2.4.5"
       },
       "engines": {
-        "node": ">=18.0.0"
-      }
-    },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/scraping/node_modules/@mintlify/common": {
-      "version": "1.0.661",
-      "resolved": "https://registry.npmjs.org/@mintlify/common/-/common-1.0.661.tgz",
-      "integrity": "sha512-/Hdiblzaomp+AWStQ4smhVMgesQhffzQjC9aYBnmLReNdh2Js+ccQFUaWL3TNIxwiS2esaZvsHSV/D+zyRS3hg==",
-      "license": "ISC",
-      "dependencies": {
-        "@asyncapi/parser": "3.4.0",
-        "@mintlify/mdx": "^3.0.4",
-        "@mintlify/models": "0.0.255",
-        "@mintlify/openapi-parser": "^0.0.8",
-        "@mintlify/validation": "0.1.555",
-        "@sindresorhus/slugify": "2.2.0",
-        "@types/mdast": "4.0.4",
-        "acorn": "8.11.2",
-        "acorn-jsx": "5.3.2",
-        "color-blend": "4.0.0",
-        "estree-util-to-js": "2.0.0",
-        "estree-walker": "3.0.3",
-        "front-matter": "4.0.2",
-        "hast-util-from-html": "2.0.3",
-        "hast-util-to-html": "9.0.4",
-        "hast-util-to-text": "4.0.2",
-        "hex-rgb": "5.0.0",
-        "ignore": "7.0.5",
-        "js-yaml": "4.1.0",
-        "lodash": "4.17.21",
-        "mdast-util-from-markdown": "2.0.2",
-        "mdast-util-gfm": "3.0.0",
-        "mdast-util-mdx": "3.0.0",
-        "mdast-util-mdx-jsx": "3.1.3",
-        "micromark-extension-gfm": "3.0.0",
-        "micromark-extension-mdx-jsx": "3.0.1",
-        "micromark-extension-mdxjs": "3.0.0",
-        "openapi-types": "12.1.3",
-        "postcss": "8.5.6",
-        "rehype-stringify": "10.0.1",
-        "remark": "15.0.1",
-        "remark-frontmatter": "5.0.0",
-        "remark-gfm": "4.0.0",
-        "remark-math": "6.0.0",
-        "remark-mdx": "3.1.0",
-        "remark-parse": "11.0.0",
-        "remark-rehype": "11.1.1",
-        "remark-stringify": "11.0.0",
-        "tailwindcss": "3.4.4",
-        "unified": "11.0.5",
-        "unist-builder": "4.0.0",
-        "unist-util-map": "4.0.0",
-        "unist-util-remove": "4.0.0",
-        "unist-util-remove-position": "5.0.0",
-        "unist-util-visit": "5.0.0",
-        "unist-util-visit-parents": "6.0.1",
-        "vfile": "6.0.3"
+        "node": ">=18"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/scraping/node_modules/@mintlify/common/node_modules/remark-mdx": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.1.0.tgz",
-      "integrity": "sha512-Ngl/H3YXyBV9RcRNdlYsZujAmhsxwzxpDzpDEhFBVAGthS4GDgnctpDjgFl/ULx5UEDzqtW1cyBSNKqYYrqLBA==",
+    "node_modules/@mintlify/openapi-parser/node_modules/ajv-formats": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz",
+      "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==",
       "license": "MIT",
       "dependencies": {
-        "mdast-util-mdx": "^3.0.0",
-        "micromark-extension-mdxjs": "^3.0.0"
+        "ajv": "^8.0.0"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "peerDependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "ajv": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/scraping/node_modules/@mintlify/validation": {
-      "version": "0.1.555",
-      "resolved": "https://registry.npmjs.org/@mintlify/validation/-/validation-0.1.555.tgz",
-      "integrity": "sha512-11QVUReL4N5u8wSCgZt4RN7PA0jYQoMEBZ5IrUp5pgb5ZJBOoGV/vPsQrxPPa1cxsUDAuToNhtGxRQtOav/w8w==",
+    "node_modules/@mintlify/prebuild": {
+      "version": "1.0.986",
+      "resolved": "https://registry.npmjs.org/@mintlify/prebuild/-/prebuild-1.0.986.tgz",
+      "integrity": "sha512-HGQwegpiP0ZwAg/kpISdtad6t5om32HZ/OCWQGHh2G3+gv2Fjg3hGRttagU88oBT9oKC1N7lJPjhxK8FrvwX3w==",
       "license": "Elastic-2.0",
       "dependencies": {
-        "@mintlify/mdx": "^3.0.4",
-        "@mintlify/models": "0.0.255",
-        "arktype": "2.1.27",
+        "@mintlify/common": "1.0.844",
+        "@mintlify/openapi-parser": "^0.0.8",
+        "@mintlify/scraping": "4.0.708",
+        "@mintlify/validation": "0.1.660",
+        "chalk": "5.3.0",
+        "favicons": "7.2.0",
+        "front-matter": "4.0.2",
+        "fs-extra": "11.1.0",
         "js-yaml": "4.1.0",
-        "lcm": "0.0.3",
-        "lodash": "4.17.21",
-        "object-hash": "3.0.0",
         "openapi-types": "12.1.3",
-        "uuid": "11.1.0",
-        "zod": "3.21.4",
-        "zod-to-json-schema": "3.20.4"
-      }
-    },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/scraping/node_modules/fs-extra": {
-      "version": "11.1.1",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.1.tgz",
-      "integrity": "sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==",
-      "license": "MIT",
-      "dependencies": {
-        "graceful-fs": "^4.2.0",
-        "jsonfile": "^6.0.1",
-        "universalify": "^2.0.0"
+        "sharp": "0.33.5",
+        "sharp-ico": "0.1.5",
+        "unist-util-visit": "4.1.2",
+        "uuid": "11.1.0"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-darwin-arm64": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.33.5.tgz",
+      "integrity": "sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
       },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-arm64": "1.0.4"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-darwin-x64": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.33.5.tgz",
+      "integrity": "sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
       "engines": {
-        "node": ">=14.14"
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-x64": "1.0.4"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/scraping/node_modules/remark-mdx": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.0.1.tgz",
-      "integrity": "sha512-3Pz3yPQ5Rht2pM5R+0J2MrGoBSrzf+tJG94N+t/ilfdh8YLyyKYtidAYwTveB20BoHAcwIopOUqhcmh2F7hGYA==",
-      "license": "MIT",
-      "dependencies": {
-        "mdast-util-mdx": "^3.0.0",
-        "micromark-extension-mdxjs": "^3.0.0"
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-darwin-arm64": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.0.4.tgz",
+      "integrity": "sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-darwin-x64": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.0.4.tgz",
+      "integrity": "sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linux-arm": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.0.5.tgz",
+      "integrity": "sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g==",
+      "cpu": [
+        "arm"
+      ],
+      "libc": [
+        "glibc"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linux-arm64": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.0.4.tgz",
+      "integrity": "sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA==",
+      "cpu": [
+        "arm64"
+      ],
+      "libc": [
+        "glibc"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linux-s390x": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.0.4.tgz",
+      "integrity": "sha512-u7Wz6ntiSSgGSGcjZ55im6uvTrOxSIS8/dgoVMoiGE9I6JAfU50yH5BoDlYA1tcuGS7g/QNtetJnxA6QEsCVTA==",
+      "cpu": [
+        "s390x"
+      ],
+      "libc": [
+        "glibc"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linux-x64": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.0.4.tgz",
+      "integrity": "sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw==",
+      "cpu": [
+        "x64"
+      ],
+      "libc": [
+        "glibc"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linuxmusl-arm64": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.0.4.tgz",
+      "integrity": "sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA==",
+      "cpu": [
+        "arm64"
+      ],
+      "libc": [
+        "musl"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linuxmusl-x64": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.0.4.tgz",
+      "integrity": "sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw==",
+      "cpu": [
+        "x64"
+      ],
+      "libc": [
+        "musl"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linux-arm": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.33.5.tgz",
+      "integrity": "sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ==",
+      "cpu": [
+        "arm"
+      ],
+      "libc": [
+        "glibc"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm": "1.0.5"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@mintlify/scraping/node_modules/unist-util-visit": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz",
-      "integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/unist": "^3.0.0",
-        "unist-util-is": "^6.0.0",
-        "unist-util-visit-parents": "^6.0.0"
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linux-arm64": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.33.5.tgz",
+      "integrity": "sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA==",
+      "cpu": [
+        "arm64"
+      ],
+      "libc": [
+        "glibc"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm64": "1.0.4"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@radix-ui/react-arrow": {
-      "version": "1.1.7",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz",
-      "integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==",
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@radix-ui/react-primitive": "2.1.3"
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linux-s390x": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.33.5.tgz",
+      "integrity": "sha512-y/5PCd+mP4CA/sPDKl2961b+C9d+vPAveS33s6Z3zfASk2j5upL6fXVPZi7ztePZ5CuH+1kW8JtvxgbuXHRa4Q==",
+      "cpu": [
+        "s390x"
+      ],
+      "libc": [
+        "glibc"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
       },
-      "peerDependencies": {
-        "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      "funding": {
+        "url": "https://opencollective.com/libvips"
       },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
-        }
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-s390x": "1.0.4"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@radix-ui/react-dismissable-layer": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
-      "integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@radix-ui/primitive": "1.1.3",
-        "@radix-ui/react-compose-refs": "1.1.2",
-        "@radix-ui/react-primitive": "2.1.3",
-        "@radix-ui/react-use-callback-ref": "1.1.1",
-        "@radix-ui/react-use-escape-keydown": "1.1.1"
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linux-x64": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.33.5.tgz",
+      "integrity": "sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA==",
+      "cpu": [
+        "x64"
+      ],
+      "libc": [
+        "glibc"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
       },
-      "peerDependencies": {
-        "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      "funding": {
+        "url": "https://opencollective.com/libvips"
       },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
-        }
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-x64": "1.0.4"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@radix-ui/react-focus-scope": {
-      "version": "1.1.7",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz",
-      "integrity": "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==",
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@radix-ui/react-compose-refs": "1.1.2",
-        "@radix-ui/react-primitive": "2.1.3",
-        "@radix-ui/react-use-callback-ref": "1.1.1"
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linuxmusl-arm64": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.33.5.tgz",
+      "integrity": "sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g==",
+      "cpu": [
+        "arm64"
+      ],
+      "libc": [
+        "musl"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
       },
-      "peerDependencies": {
-        "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      "funding": {
+        "url": "https://opencollective.com/libvips"
       },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
-        }
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-arm64": "1.0.4"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@radix-ui/react-popover": {
-      "version": "1.1.15",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-popover/-/react-popover-1.1.15.tgz",
-      "integrity": "sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA==",
-      "license": "MIT",
-      "peer": true,
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linuxmusl-x64": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.33.5.tgz",
+      "integrity": "sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw==",
+      "cpu": [
+        "x64"
+      ],
+      "libc": [
+        "musl"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-x64": "1.0.4"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-wasm32": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.33.5.tgz",
+      "integrity": "sha512-ykUW4LVGaMcU9lu9thv85CbRMAwfeadCJHRsg2GmeRa/cJxsVY9Rbd57JcMxBkKHag5U/x7TSBpScF4U8ElVzg==",
+      "cpu": [
+        "wasm32"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
+      "optional": true,
       "dependencies": {
-        "@radix-ui/primitive": "1.1.3",
-        "@radix-ui/react-compose-refs": "1.1.2",
-        "@radix-ui/react-context": "1.1.2",
-        "@radix-ui/react-dismissable-layer": "1.1.11",
-        "@radix-ui/react-focus-guards": "1.1.3",
-        "@radix-ui/react-focus-scope": "1.1.7",
-        "@radix-ui/react-id": "1.1.1",
-        "@radix-ui/react-popper": "1.2.8",
-        "@radix-ui/react-portal": "1.1.9",
-        "@radix-ui/react-presence": "1.1.5",
-        "@radix-ui/react-primitive": "2.1.3",
-        "@radix-ui/react-slot": "1.2.3",
-        "@radix-ui/react-use-controllable-state": "1.2.2",
-        "aria-hidden": "^1.2.4",
-        "react-remove-scroll": "^2.6.3"
+        "@emnapi/runtime": "^1.2.0"
       },
-      "peerDependencies": {
-        "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-win32-ia32": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.33.5.tgz",
+      "integrity": "sha512-T36PblLaTwuVJ/zw/LaH0PdZkRz5rd3SmMHX8GSmR7vtNSP5Z6bQkExdSK7xGWyxLw4sUknBuugTelgw2faBbQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
       },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
-        }
+      "funding": {
+        "url": "https://opencollective.com/libvips"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@radix-ui/react-popper": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
-      "integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@floating-ui/react-dom": "^2.0.0",
-        "@radix-ui/react-arrow": "1.1.7",
-        "@radix-ui/react-compose-refs": "1.1.2",
-        "@radix-ui/react-context": "1.1.2",
-        "@radix-ui/react-primitive": "2.1.3",
-        "@radix-ui/react-use-callback-ref": "1.1.1",
-        "@radix-ui/react-use-layout-effect": "1.1.1",
-        "@radix-ui/react-use-rect": "1.1.1",
-        "@radix-ui/react-use-size": "1.1.1",
-        "@radix-ui/rect": "1.1.1"
-      },
-      "peerDependencies": {
-        "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-win32-x64": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.33.5.tgz",
+      "integrity": "sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
       },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
-        }
+      "funding": {
+        "url": "https://opencollective.com/libvips"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@radix-ui/react-portal": {
-      "version": "1.1.9",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz",
-      "integrity": "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==",
-      "license": "MIT",
-      "peer": true,
+    "node_modules/@mintlify/prebuild/node_modules/@mintlify/scraping": {
+      "version": "4.0.708",
+      "resolved": "https://registry.npmjs.org/@mintlify/scraping/-/scraping-4.0.708.tgz",
+      "integrity": "sha512-6GDxVKM7B0NqxXvg4Mm8nVhtybAzkVRZcMGtsp5OoHZrnATZ/C4wv2B82ZnwZvdhzLDATWoSoe3W14IXgYYcCQ==",
+      "license": "Elastic-2.0",
       "dependencies": {
-        "@radix-ui/react-primitive": "2.1.3",
-        "@radix-ui/react-use-layout-effect": "1.1.1"
+        "@mintlify/common": "1.0.844",
+        "@mintlify/openapi-parser": "^0.0.8",
+        "fs-extra": "11.1.1",
+        "hast-util-to-mdast": "10.1.0",
+        "js-yaml": "4.1.0",
+        "mdast-util-mdx-jsx": "3.1.3",
+        "neotraverse": "0.6.18",
+        "puppeteer": "22.14.0",
+        "rehype-parse": "9.0.1",
+        "remark-gfm": "4.0.0",
+        "remark-mdx": "3.0.1",
+        "remark-parse": "11.0.0",
+        "remark-stringify": "11.0.0",
+        "unified": "11.0.5",
+        "unist-util-visit": "5.0.0",
+        "yargs": "17.7.1",
+        "zod": "3.24.0"
       },
-      "peerDependencies": {
-        "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      "bin": {
+        "mintlify-scrape": "bin/cli.js"
       },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
-        }
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@radix-ui/react-presence": {
-      "version": "1.1.5",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
-      "integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
+    "node_modules/@mintlify/prebuild/node_modules/@mintlify/scraping/node_modules/fs-extra": {
+      "version": "11.1.1",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.1.tgz",
+      "integrity": "sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "@radix-ui/react-compose-refs": "1.1.2",
-        "@radix-ui/react-use-layout-effect": "1.1.1"
-      },
-      "peerDependencies": {
-        "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
       },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
-        }
+      "engines": {
+        "node": ">=14.14"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/@radix-ui/react-primitive": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz",
-      "integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==",
+    "node_modules/@mintlify/prebuild/node_modules/@mintlify/scraping/node_modules/unist-util-visit": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz",
+      "integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "@radix-ui/react-slot": "1.2.3"
-      },
-      "peerDependencies": {
-        "@types/react": "*",
-        "@types/react-dom": "*",
-        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
-        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
       },
-      "peerDependenciesMeta": {
-        "@types/react": {
-          "optional": true
-        },
-        "@types/react-dom": {
-          "optional": true
-        }
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/axios": {
-      "version": "1.10.0",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.10.0.tgz",
-      "integrity": "sha512-/1xYAC4MP/HEG+3duIhFr4ZQXR4sQXOIe+o6sdqzeykGLx6Upp/1p8MHqhINOvGeP7xyNHe7tsiJByc4SSVUxw==",
+    "node_modules/@mintlify/prebuild/node_modules/chalk": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz",
+      "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==",
       "license": "MIT",
-      "dependencies": {
-        "follow-redirects": "^1.15.6",
-        "form-data": "^4.0.0",
-        "proxy-from-env": "^1.1.0"
+      "engines": {
+        "node": "^12.17.0 || ^14.13 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/fs-extra": {
+    "node_modules/@mintlify/prebuild/node_modules/fs-extra": {
       "version": "11.1.0",
       "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.0.tgz",
       "integrity": "sha512-0rcTq621PD5jM/e0a3EJoGC/1TC5ZBCERW82LQuwfGnCa1V8w7dpYH1yNu+SLb6E5dkeCBzKEyLGlFrnr+dUyw==",
@@ -2118,7 +2261,7 @@
         "node": ">=14.14"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/mdast-util-mdx-jsx": {
+    "node_modules/@mintlify/prebuild/node_modules/mdast-util-mdx-jsx": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.3.tgz",
       "integrity": "sha512-bfOjvNt+1AcbPLTFMFWY149nJz0OjmewJs3LQQ5pIyVGxP4CdOqNVJL6kTaM5c68p8q82Xv3nCyFfUnuEcH3UQ==",
@@ -2142,66 +2285,60 @@
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/next-mdx-remote-client": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/next-mdx-remote-client/-/next-mdx-remote-client-1.1.6.tgz",
-      "integrity": "sha512-O4HIpi44d6SismhfG5W78aTUfgxfbsj6FgoM4/G3o4Vtcobt0Ej439IiDPkv+IqsmtouVYG1tGAsz1DIuj9Tfg==",
-      "license": "MPL 2.0",
+    "node_modules/@mintlify/prebuild/node_modules/remark-mdx": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.0.1.tgz",
+      "integrity": "sha512-3Pz3yPQ5Rht2pM5R+0J2MrGoBSrzf+tJG94N+t/ilfdh8YLyyKYtidAYwTveB20BoHAcwIopOUqhcmh2F7hGYA==",
+      "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.29.0",
-        "@mdx-js/mdx": "^3.1.1",
-        "@mdx-js/react": "^3.1.1",
-        "remark-mdx-remove-esm": "^1.2.3",
-        "serialize-error": "^13.0.1",
-        "vfile": "^6.0.3",
-        "vfile-matter": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=20.9.0"
+        "mdast-util-mdx": "^3.0.0",
+        "micromark-extension-mdxjs": "^3.0.0"
       },
-      "peerDependencies": {
-        "react": ">= 18.3.0 < 19.0.0",
-        "react-dom": ">= 18.3.0 < 19.0.0"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/react": {
-      "version": "18.3.1",
-      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
-      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
-      "license": "MIT",
-      "peer": true,
+    "node_modules/@mintlify/prebuild/node_modules/sharp": {
+      "version": "0.33.5",
+      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.33.5.tgz",
+      "integrity": "sha512-haPVm1EkS9pgvHrQ/F3Xy+hgcuMV0Wm9vfIBSiwZ05k+xgb0PkBQpGsAA/oWdDobNaZTH5ppvHtzCFbnSEwHVw==",
+      "hasInstallScript": true,
+      "license": "Apache-2.0",
       "dependencies": {
-        "loose-envify": "^1.1.0"
+        "color": "^4.2.3",
+        "detect-libc": "^2.0.3",
+        "semver": "^7.6.3"
       },
       "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/@mintlify/link-rot/node_modules/react-dom": {
-      "version": "18.3.1",
-      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
-      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "loose-envify": "^1.1.0",
-        "scheduler": "^0.23.2"
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
       },
-      "peerDependencies": {
-        "react": "^18.3.1"
-      }
-    },
-    "node_modules/@mintlify/link-rot/node_modules/scheduler": {
-      "version": "0.23.2",
-      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
-      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "loose-envify": "^1.1.0"
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-darwin-arm64": "0.33.5",
+        "@img/sharp-darwin-x64": "0.33.5",
+        "@img/sharp-libvips-darwin-arm64": "1.0.4",
+        "@img/sharp-libvips-darwin-x64": "1.0.4",
+        "@img/sharp-libvips-linux-arm": "1.0.5",
+        "@img/sharp-libvips-linux-arm64": "1.0.4",
+        "@img/sharp-libvips-linux-s390x": "1.0.4",
+        "@img/sharp-libvips-linux-x64": "1.0.4",
+        "@img/sharp-libvips-linuxmusl-arm64": "1.0.4",
+        "@img/sharp-libvips-linuxmusl-x64": "1.0.4",
+        "@img/sharp-linux-arm": "0.33.5",
+        "@img/sharp-linux-arm64": "0.33.5",
+        "@img/sharp-linux-s390x": "0.33.5",
+        "@img/sharp-linux-x64": "0.33.5",
+        "@img/sharp-linuxmusl-arm64": "0.33.5",
+        "@img/sharp-linuxmusl-x64": "0.33.5",
+        "@img/sharp-wasm32": "0.33.5",
+        "@img/sharp-win32-ia32": "0.33.5",
+        "@img/sharp-win32-x64": "0.33.5"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/unist-util-visit": {
+    "node_modules/@mintlify/prebuild/node_modules/unist-util-visit": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz",
       "integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==",
@@ -2216,13 +2353,13 @@
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/unist-util-visit/node_modules/@types/unist": {
+    "node_modules/@mintlify/prebuild/node_modules/unist-util-visit/node_modules/@types/unist": {
       "version": "2.0.11",
       "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
       "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
       "license": "MIT"
     },
-    "node_modules/@mintlify/link-rot/node_modules/unist-util-visit/node_modules/unist-util-is": {
+    "node_modules/@mintlify/prebuild/node_modules/unist-util-visit/node_modules/unist-util-is": {
       "version": "5.2.1",
       "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz",
       "integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==",
@@ -2235,7 +2372,7 @@
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/unist-util-visit/node_modules/unist-util-visit-parents": {
+    "node_modules/@mintlify/prebuild/node_modules/unist-util-visit/node_modules/unist-util-visit-parents": {
       "version": "5.1.3",
       "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz",
       "integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==",
@@ -2249,467 +2386,565 @@
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/link-rot/node_modules/zod": {
-      "version": "3.21.4",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-3.21.4.tgz",
-      "integrity": "sha512-m46AKbrzKVzOzs/DZgVnG5H55N1sv1M8qZU3A8RIKbs3mrACDNeIOeilDymVb2HdmP8uwshOCF4uJ8uM9rCqJw==",
+    "node_modules/@mintlify/prebuild/node_modules/zod": {
+      "version": "3.24.0",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.0.tgz",
+      "integrity": "sha512-Hz+wiY8yD0VLA2k/+nsg2Abez674dDGTai33SwNvMPuf9uIrBC9eFgIMQxBBbHFxVXi8W+5nX9DcAh9YNSQm/w==",
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }
     },
-    "node_modules/@mintlify/models": {
-      "version": "0.0.283",
-      "resolved": "https://registry.npmjs.org/@mintlify/models/-/models-0.0.283.tgz",
-      "integrity": "sha512-UY4PgxMZqD9QN6G0uSZgTLlMf7Ik0pliw+0AUPm+PGIlsIUMHfB1OyxuWZl9BD3Kpqm61QHI61Ud77NAGRUfUA==",
+    "node_modules/@mintlify/previewing": {
+      "version": "4.0.1047",
+      "resolved": "https://registry.npmjs.org/@mintlify/previewing/-/previewing-4.0.1047.tgz",
+      "integrity": "sha512-4/k7a/kXkD8LK7nHvRGEPCvigpeunFk2Ku07wlXLR4tB8OEG6v5ZjLFKVHArd+UuRmjHB/oBcCht3DARaizPOw==",
       "license": "Elastic-2.0",
       "dependencies": {
-        "axios": "1.13.2",
-        "openapi-types": "12.1.3"
+        "@mintlify/common": "1.0.844",
+        "@mintlify/prebuild": "1.0.986",
+        "@mintlify/validation": "0.1.660",
+        "adm-zip": "0.5.16",
+        "better-opn": "3.0.2",
+        "chalk": "5.2.0",
+        "chokidar": "3.5.3",
+        "express": "4.18.2",
+        "front-matter": "4.0.2",
+        "fs-extra": "11.1.0",
+        "got": "13.0.0",
+        "ink": "6.3.0",
+        "ink-spinner": "5.0.0",
+        "is-online": "10.0.0",
+        "js-yaml": "4.1.0",
+        "openapi-types": "12.1.3",
+        "react": "19.2.3",
+        "socket.io": "4.7.2",
+        "tar": "6.1.15",
+        "unist-util-visit": "4.1.2",
+        "yargs": "17.7.1"
       },
       "engines": {
         "node": ">=18.0.0"
       }
     },
-    "node_modules/@mintlify/openapi-parser": {
-      "version": "0.0.8",
-      "resolved": "https://registry.npmjs.org/@mintlify/openapi-parser/-/openapi-parser-0.0.8.tgz",
-      "integrity": "sha512-9MBRq9lS4l4HITYCrqCL7T61MOb20q9IdU7HWhqYMNMM1jGO1nHjXasFy61yZ8V6gMZyyKQARGVoZ0ZrYN48Og==",
+    "node_modules/@mintlify/previewing/node_modules/@types/unist": {
+      "version": "2.0.11",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
+      "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
+      "license": "MIT"
+    },
+    "node_modules/@mintlify/previewing/node_modules/fs-extra": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.0.tgz",
+      "integrity": "sha512-0rcTq621PD5jM/e0a3EJoGC/1TC5ZBCERW82LQuwfGnCa1V8w7dpYH1yNu+SLb6E5dkeCBzKEyLGlFrnr+dUyw==",
       "license": "MIT",
       "dependencies": {
-        "ajv": "^8.17.1",
-        "ajv-draft-04": "^1.0.0",
-        "ajv-formats": "^3.0.1",
-        "jsonpointer": "^5.0.1",
-        "leven": "^4.0.0",
-        "yaml": "^2.4.5"
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
       },
       "engines": {
-        "node": ">=18"
+        "node": ">=14.14"
       }
     },
-    "node_modules/@mintlify/openapi-parser/node_modules/ajv-formats": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz",
-      "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==",
+    "node_modules/@mintlify/previewing/node_modules/unist-util-is": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz",
+      "integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==",
       "license": "MIT",
       "dependencies": {
-        "ajv": "^8.0.0"
-      },
-      "peerDependencies": {
-        "ajv": "^8.0.0"
+        "@types/unist": "^2.0.0"
       },
-      "peerDependenciesMeta": {
-        "ajv": {
-          "optional": true
-        }
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/prebuild": {
-      "version": "1.0.917",
-      "resolved": "https://registry.npmjs.org/@mintlify/prebuild/-/prebuild-1.0.917.tgz",
-      "integrity": "sha512-wZgI5Phc36Qy7Q2eW/NhcSoNCm7qG1TlxOMsyaOj6D+rrPy+vgPhhM/orRWOHw2eYEXqcqThqBYnUeq6WxXnTg==",
-      "license": "Elastic-2.0",
+    "node_modules/@mintlify/previewing/node_modules/unist-util-visit": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz",
+      "integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==",
+      "license": "MIT",
       "dependencies": {
-        "@mintlify/common": "1.0.779",
-        "@mintlify/openapi-parser": "^0.0.8",
-        "@mintlify/scraping": "4.0.641",
-        "@mintlify/validation": "0.1.626",
-        "chalk": "5.3.0",
-        "favicons": "7.2.0",
-        "front-matter": "4.0.2",
-        "fs-extra": "11.1.0",
-        "js-yaml": "4.1.0",
-        "openapi-types": "12.1.3",
-        "sharp": "0.33.5",
-        "sharp-ico": "0.1.5",
-        "unist-util-visit": "4.1.2",
-        "uuid": "11.1.0"
-      }
-    },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-darwin-arm64": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.33.5.tgz",
-      "integrity": "sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0",
+        "unist-util-visit-parents": "^5.1.1"
       },
       "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-darwin-arm64": "1.0.4"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-darwin-x64": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.33.5.tgz",
-      "integrity": "sha512-fyHac4jIc1ANYGRDxtiqelIbdWkIuQaI84Mv45KvGRRxSAa7o7d1ZKAOBaYbnepLC1WqxfpimdeWfvqqSGwR2Q==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+    "node_modules/@mintlify/previewing/node_modules/unist-util-visit-parents": {
+      "version": "5.1.3",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz",
+      "integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "unist-util-is": "^5.0.0"
       },
       "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-darwin-x64": "1.0.4"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-darwin-arm64": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.0.4.tgz",
-      "integrity": "sha512-XblONe153h0O2zuFfTAbQYAX2JhYmDHeWikp1LM9Hul9gVPjFY427k6dFEcOL72O01QxQsWi761svJ/ev9xEDg==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+    "node_modules/@mintlify/scraping": {
+      "version": "4.0.522",
+      "resolved": "https://registry.npmjs.org/@mintlify/scraping/-/scraping-4.0.522.tgz",
+      "integrity": "sha512-PL2k52WT5S5OAgnT2K13bP7J2El6XwiVvQlrLvxDYw5KMMV+y34YVJI8ZscKb4trjitWDgyK0UTq2KN6NQgn6g==",
+      "license": "Elastic-2.0",
+      "dependencies": {
+        "@mintlify/common": "1.0.661",
+        "@mintlify/openapi-parser": "^0.0.8",
+        "fs-extra": "11.1.1",
+        "hast-util-to-mdast": "10.1.0",
+        "js-yaml": "4.1.0",
+        "mdast-util-mdx-jsx": "3.1.3",
+        "neotraverse": "0.6.18",
+        "puppeteer": "22.14.0",
+        "rehype-parse": "9.0.1",
+        "remark-gfm": "4.0.0",
+        "remark-mdx": "3.0.1",
+        "remark-parse": "11.0.0",
+        "remark-stringify": "11.0.0",
+        "unified": "11.0.5",
+        "unist-util-visit": "5.0.0",
+        "yargs": "17.7.1",
+        "zod": "3.21.4"
+      },
+      "bin": {
+        "mintlify-scrape": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-darwin-x64": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.0.4.tgz",
-      "integrity": "sha512-xnGR8YuZYfJGmWPvmlunFaWJsb9T/AO2ykoP3Fz/0X5XV2aoYBPkX6xqCQvUTKKiLddarLaxpzNe+b1hjeWHAQ==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+    "node_modules/@mintlify/scraping/node_modules/@floating-ui/react-dom": {
+      "version": "2.1.8",
+      "resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.8.tgz",
+      "integrity": "sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@floating-ui/dom": "^1.7.6"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0",
+        "react-dom": ">=16.8.0"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linux-arm": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.0.5.tgz",
-      "integrity": "sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g==",
-      "cpu": [
-        "arm"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+    "node_modules/@mintlify/scraping/node_modules/@mintlify/common": {
+      "version": "1.0.661",
+      "resolved": "https://registry.npmjs.org/@mintlify/common/-/common-1.0.661.tgz",
+      "integrity": "sha512-/Hdiblzaomp+AWStQ4smhVMgesQhffzQjC9aYBnmLReNdh2Js+ccQFUaWL3TNIxwiS2esaZvsHSV/D+zyRS3hg==",
+      "license": "ISC",
+      "dependencies": {
+        "@asyncapi/parser": "3.4.0",
+        "@mintlify/mdx": "^3.0.4",
+        "@mintlify/models": "0.0.255",
+        "@mintlify/openapi-parser": "^0.0.8",
+        "@mintlify/validation": "0.1.555",
+        "@sindresorhus/slugify": "2.2.0",
+        "@types/mdast": "4.0.4",
+        "acorn": "8.11.2",
+        "acorn-jsx": "5.3.2",
+        "color-blend": "4.0.0",
+        "estree-util-to-js": "2.0.0",
+        "estree-walker": "3.0.3",
+        "front-matter": "4.0.2",
+        "hast-util-from-html": "2.0.3",
+        "hast-util-to-html": "9.0.4",
+        "hast-util-to-text": "4.0.2",
+        "hex-rgb": "5.0.0",
+        "ignore": "7.0.5",
+        "js-yaml": "4.1.0",
+        "lodash": "4.17.21",
+        "mdast-util-from-markdown": "2.0.2",
+        "mdast-util-gfm": "3.0.0",
+        "mdast-util-mdx": "3.0.0",
+        "mdast-util-mdx-jsx": "3.1.3",
+        "micromark-extension-gfm": "3.0.0",
+        "micromark-extension-mdx-jsx": "3.0.1",
+        "micromark-extension-mdxjs": "3.0.0",
+        "openapi-types": "12.1.3",
+        "postcss": "8.5.6",
+        "rehype-stringify": "10.0.1",
+        "remark": "15.0.1",
+        "remark-frontmatter": "5.0.0",
+        "remark-gfm": "4.0.0",
+        "remark-math": "6.0.0",
+        "remark-mdx": "3.1.0",
+        "remark-parse": "11.0.0",
+        "remark-rehype": "11.1.1",
+        "remark-stringify": "11.0.0",
+        "tailwindcss": "3.4.4",
+        "unified": "11.0.5",
+        "unist-builder": "4.0.0",
+        "unist-util-map": "4.0.0",
+        "unist-util-remove": "4.0.0",
+        "unist-util-remove-position": "5.0.0",
+        "unist-util-visit": "5.0.0",
+        "unist-util-visit-parents": "6.0.1",
+        "vfile": "6.0.3"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linux-arm64": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.0.4.tgz",
-      "integrity": "sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+    "node_modules/@mintlify/scraping/node_modules/@mintlify/common/node_modules/remark-mdx": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.1.0.tgz",
+      "integrity": "sha512-Ngl/H3YXyBV9RcRNdlYsZujAmhsxwzxpDzpDEhFBVAGthS4GDgnctpDjgFl/ULx5UEDzqtW1cyBSNKqYYrqLBA==",
+      "license": "MIT",
+      "dependencies": {
+        "mdast-util-mdx": "^3.0.0",
+        "micromark-extension-mdxjs": "^3.0.0"
+      },
       "funding": {
-        "url": "https://opencollective.com/libvips"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linux-s390x": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.0.4.tgz",
-      "integrity": "sha512-u7Wz6ntiSSgGSGcjZ55im6uvTrOxSIS8/dgoVMoiGE9I6JAfU50yH5BoDlYA1tcuGS7g/QNtetJnxA6QEsCVTA==",
-      "cpu": [
-        "s390x"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+    "node_modules/@mintlify/scraping/node_modules/@mintlify/mdx": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@mintlify/mdx/-/mdx-3.0.4.tgz",
+      "integrity": "sha512-tJhdpnM5ReJLNJ2fuDRIEr0zgVd6id7/oAIfs26V46QlygiLsc8qx4Rz3LWIX51rUXW/cfakjj0EATxIciIw+g==",
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/transformers": "^3.11.0",
+        "@shikijs/twoslash": "^3.12.2",
+        "arktype": "^2.1.26",
+        "hast-util-to-string": "^3.0.1",
+        "mdast-util-from-markdown": "^2.0.2",
+        "mdast-util-gfm": "^3.1.0",
+        "mdast-util-mdx-jsx": "^3.2.0",
+        "mdast-util-to-hast": "^13.2.0",
+        "next-mdx-remote-client": "^1.0.3",
+        "rehype-katex": "^7.0.1",
+        "remark-gfm": "^4.0.0",
+        "remark-math": "^6.0.0",
+        "remark-smartypants": "^3.0.2",
+        "shiki": "^3.11.0",
+        "unified": "^11.0.0",
+        "unist-util-visit": "^5.0.0"
+      },
+      "peerDependencies": {
+        "@radix-ui/react-popover": "^1.1.15",
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linux-x64": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.0.4.tgz",
-      "integrity": "sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+    "node_modules/@mintlify/scraping/node_modules/@mintlify/mdx/node_modules/mdast-util-gfm": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz",
+      "integrity": "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==",
+      "license": "MIT",
+      "dependencies": {
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-gfm-autolink-literal": "^2.0.0",
+        "mdast-util-gfm-footnote": "^2.0.0",
+        "mdast-util-gfm-strikethrough": "^2.0.0",
+        "mdast-util-gfm-table": "^2.0.0",
+        "mdast-util-gfm-task-list-item": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
       "funding": {
-        "url": "https://opencollective.com/libvips"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linuxmusl-arm64": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.0.4.tgz",
-      "integrity": "sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+    "node_modules/@mintlify/scraping/node_modules/@mintlify/mdx/node_modules/mdast-util-mdx-jsx": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz",
+      "integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "parse-entities": "^4.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-stringify-position": "^4.0.0",
+        "vfile-message": "^4.0.0"
+      },
       "funding": {
-        "url": "https://opencollective.com/libvips"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-libvips-linuxmusl-x64": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.0.4.tgz",
-      "integrity": "sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+    "node_modules/@mintlify/scraping/node_modules/@mintlify/models": {
+      "version": "0.0.255",
+      "resolved": "https://registry.npmjs.org/@mintlify/models/-/models-0.0.255.tgz",
+      "integrity": "sha512-LIUkfA7l7ypHAAuOW74ZJws/NwNRqlDRD/U466jarXvvSlGhJec/6J4/I+IEcBvWDnc9anLFKmnGO04jPKgAsg==",
+      "license": "Elastic-2.0",
+      "dependencies": {
+        "axios": "1.10.0",
+        "openapi-types": "12.1.3"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linux-arm": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.33.5.tgz",
-      "integrity": "sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ==",
-      "cpu": [
-        "arm"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-arm": "1.0.5"
+    "node_modules/@mintlify/scraping/node_modules/@mintlify/validation": {
+      "version": "0.1.555",
+      "resolved": "https://registry.npmjs.org/@mintlify/validation/-/validation-0.1.555.tgz",
+      "integrity": "sha512-11QVUReL4N5u8wSCgZt4RN7PA0jYQoMEBZ5IrUp5pgb5ZJBOoGV/vPsQrxPPa1cxsUDAuToNhtGxRQtOav/w8w==",
+      "license": "Elastic-2.0",
+      "dependencies": {
+        "@mintlify/mdx": "^3.0.4",
+        "@mintlify/models": "0.0.255",
+        "arktype": "2.1.27",
+        "js-yaml": "4.1.0",
+        "lcm": "0.0.3",
+        "lodash": "4.17.21",
+        "object-hash": "3.0.0",
+        "openapi-types": "12.1.3",
+        "uuid": "11.1.0",
+        "zod": "3.21.4",
+        "zod-to-json-schema": "3.20.4"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linux-arm64": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.33.5.tgz",
-      "integrity": "sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+    "node_modules/@mintlify/scraping/node_modules/@radix-ui/react-arrow": {
+      "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz",
+      "integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@radix-ui/react-primitive": "2.1.3"
       },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
       },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-arm64": "1.0.4"
-      }
-    },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linux-s390x": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.33.5.tgz",
-      "integrity": "sha512-y/5PCd+mP4CA/sPDKl2961b+C9d+vPAveS33s6Z3zfASk2j5upL6fXVPZi7ztePZ5CuH+1kW8JtvxgbuXHRa4Q==",
-      "cpu": [
-        "s390x"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@mintlify/scraping/node_modules/@radix-ui/react-dismissable-layer": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
+      "integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@radix-ui/primitive": "1.1.3",
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-primitive": "2.1.3",
+        "@radix-ui/react-use-callback-ref": "1.1.1",
+        "@radix-ui/react-use-escape-keydown": "1.1.1"
       },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
       },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-s390x": "1.0.4"
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linux-x64": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.33.5.tgz",
-      "integrity": "sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+    "node_modules/@mintlify/scraping/node_modules/@radix-ui/react-focus-scope": {
+      "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz",
+      "integrity": "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-primitive": "2.1.3",
+        "@radix-ui/react-use-callback-ref": "1.1.1"
       },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
       },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-x64": "1.0.4"
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linuxmusl-arm64": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.33.5.tgz",
-      "integrity": "sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+    "node_modules/@mintlify/scraping/node_modules/@radix-ui/react-popover": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-popover/-/react-popover-1.1.15.tgz",
+      "integrity": "sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@radix-ui/primitive": "1.1.3",
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-context": "1.1.2",
+        "@radix-ui/react-dismissable-layer": "1.1.11",
+        "@radix-ui/react-focus-guards": "1.1.3",
+        "@radix-ui/react-focus-scope": "1.1.7",
+        "@radix-ui/react-id": "1.1.1",
+        "@radix-ui/react-popper": "1.2.8",
+        "@radix-ui/react-portal": "1.1.9",
+        "@radix-ui/react-presence": "1.1.5",
+        "@radix-ui/react-primitive": "2.1.3",
+        "@radix-ui/react-slot": "1.2.3",
+        "@radix-ui/react-use-controllable-state": "1.2.2",
+        "aria-hidden": "^1.2.4",
+        "react-remove-scroll": "^2.6.3"
       },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
       },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linuxmusl-arm64": "1.0.4"
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-linuxmusl-x64": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.33.5.tgz",
-      "integrity": "sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+    "node_modules/@mintlify/scraping/node_modules/@radix-ui/react-popper": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
+      "integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@floating-ui/react-dom": "^2.0.0",
+        "@radix-ui/react-arrow": "1.1.7",
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-context": "1.1.2",
+        "@radix-ui/react-primitive": "2.1.3",
+        "@radix-ui/react-use-callback-ref": "1.1.1",
+        "@radix-ui/react-use-layout-effect": "1.1.1",
+        "@radix-ui/react-use-rect": "1.1.1",
+        "@radix-ui/react-use-size": "1.1.1",
+        "@radix-ui/rect": "1.1.1"
       },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
       },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linuxmusl-x64": "1.0.4"
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-wasm32": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.33.5.tgz",
-      "integrity": "sha512-ykUW4LVGaMcU9lu9thv85CbRMAwfeadCJHRsg2GmeRa/cJxsVY9Rbd57JcMxBkKHag5U/x7TSBpScF4U8ElVzg==",
-      "cpu": [
-        "wasm32"
-      ],
-      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
-      "optional": true,
+    "node_modules/@mintlify/scraping/node_modules/@radix-ui/react-portal": {
+      "version": "1.1.9",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz",
+      "integrity": "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==",
+      "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@emnapi/runtime": "^1.2.0"
+        "@radix-ui/react-primitive": "2.1.3",
+        "@radix-ui/react-use-layout-effect": "1.1.1"
       },
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
       },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-win32-ia32": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.33.5.tgz",
-      "integrity": "sha512-T36PblLaTwuVJ/zw/LaH0PdZkRz5rd3SmMHX8GSmR7vtNSP5Z6bQkExdSK7xGWyxLw4sUknBuugTelgw2faBbQ==",
-      "cpu": [
-        "ia32"
-      ],
-      "license": "Apache-2.0 AND LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+    "node_modules/@mintlify/scraping/node_modules/@radix-ui/react-presence": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
+      "integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-use-layout-effect": "1.1.1"
       },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@img/sharp-win32-x64": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.33.5.tgz",
-      "integrity": "sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "Apache-2.0 AND LGPL-3.0-or-later",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+    "node_modules/@mintlify/scraping/node_modules/@radix-ui/react-primitive": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz",
+      "integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@radix-ui/react-slot": "1.2.3"
       },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/@types/unist": {
-      "version": "2.0.11",
-      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
-      "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
-      "license": "MIT"
-    },
-    "node_modules/@mintlify/prebuild/node_modules/chalk": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz",
-      "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==",
+    "node_modules/@mintlify/scraping/node_modules/axios": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.10.0.tgz",
+      "integrity": "sha512-/1xYAC4MP/HEG+3duIhFr4ZQXR4sQXOIe+o6sdqzeykGLx6Upp/1p8MHqhINOvGeP7xyNHe7tsiJByc4SSVUxw==",
       "license": "MIT",
-      "engines": {
-        "node": "^12.17.0 || ^14.13 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/fs-extra": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.0.tgz",
-      "integrity": "sha512-0rcTq621PD5jM/e0a3EJoGC/1TC5ZBCERW82LQuwfGnCa1V8w7dpYH1yNu+SLb6E5dkeCBzKEyLGlFrnr+dUyw==",
+    "node_modules/@mintlify/scraping/node_modules/fs-extra": {
+      "version": "11.1.1",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.1.tgz",
+      "integrity": "sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==",
       "license": "MIT",
       "dependencies": {
         "graceful-fs": "^4.2.0",
@@ -2720,275 +2955,239 @@
         "node": ">=14.14"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/sharp": {
-      "version": "0.33.5",
-      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.33.5.tgz",
-      "integrity": "sha512-haPVm1EkS9pgvHrQ/F3Xy+hgcuMV0Wm9vfIBSiwZ05k+xgb0PkBQpGsAA/oWdDobNaZTH5ppvHtzCFbnSEwHVw==",
-      "hasInstallScript": true,
-      "license": "Apache-2.0",
+    "node_modules/@mintlify/scraping/node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "license": "ISC",
       "dependencies": {
-        "color": "^4.2.3",
-        "detect-libc": "^2.0.3",
-        "semver": "^7.6.3"
+        "is-glob": "^4.0.3"
       },
       "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-darwin-arm64": "0.33.5",
-        "@img/sharp-darwin-x64": "0.33.5",
-        "@img/sharp-libvips-darwin-arm64": "1.0.4",
-        "@img/sharp-libvips-darwin-x64": "1.0.4",
-        "@img/sharp-libvips-linux-arm": "1.0.5",
-        "@img/sharp-libvips-linux-arm64": "1.0.4",
-        "@img/sharp-libvips-linux-s390x": "1.0.4",
-        "@img/sharp-libvips-linux-x64": "1.0.4",
-        "@img/sharp-libvips-linuxmusl-arm64": "1.0.4",
-        "@img/sharp-libvips-linuxmusl-x64": "1.0.4",
-        "@img/sharp-linux-arm": "0.33.5",
-        "@img/sharp-linux-arm64": "0.33.5",
-        "@img/sharp-linux-s390x": "0.33.5",
-        "@img/sharp-linux-x64": "0.33.5",
-        "@img/sharp-linuxmusl-arm64": "0.33.5",
-        "@img/sharp-linuxmusl-x64": "0.33.5",
-        "@img/sharp-wasm32": "0.33.5",
-        "@img/sharp-win32-ia32": "0.33.5",
-        "@img/sharp-win32-x64": "0.33.5"
-      }
-    },
-    "node_modules/@mintlify/prebuild/node_modules/unist-util-is": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz",
-      "integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/unist": "^2.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "node": ">=10.13.0"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/unist-util-visit": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz",
-      "integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==",
+    "node_modules/@mintlify/scraping/node_modules/lilconfig": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz",
+      "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==",
       "license": "MIT",
-      "dependencies": {
-        "@types/unist": "^2.0.0",
-        "unist-util-is": "^5.0.0",
-        "unist-util-visit-parents": "^5.1.1"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "engines": {
+        "node": ">=10"
       }
     },
-    "node_modules/@mintlify/prebuild/node_modules/unist-util-visit-parents": {
-      "version": "5.1.3",
-      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz",
-      "integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==",
+    "node_modules/@mintlify/scraping/node_modules/mdast-util-mdx-jsx": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.3.tgz",
+      "integrity": "sha512-bfOjvNt+1AcbPLTFMFWY149nJz0OjmewJs3LQQ5pIyVGxP4CdOqNVJL6kTaM5c68p8q82Xv3nCyFfUnuEcH3UQ==",
       "license": "MIT",
       "dependencies": {
-        "@types/unist": "^2.0.0",
-        "unist-util-is": "^5.0.0"
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "parse-entities": "^4.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-stringify-position": "^4.0.0",
+        "vfile-message": "^4.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/previewing": {
-      "version": "4.0.975",
-      "resolved": "https://registry.npmjs.org/@mintlify/previewing/-/previewing-4.0.975.tgz",
-      "integrity": "sha512-AKTQFvicWLpaVcF9bm42INfP++qFYEb4BimwM3M2QgT+/JcRZJ7bByuazbhFDllVLuD3Wr/0X8Anq5wfeHhVQw==",
-      "license": "Elastic-2.0",
+    "node_modules/@mintlify/scraping/node_modules/next-mdx-remote-client": {
+      "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/next-mdx-remote-client/-/next-mdx-remote-client-1.1.7.tgz",
+      "integrity": "sha512-12Ap5Z/tFIETMXFSBTH2IFEhJAso7MvOJ5ICyesA4q6FM4vtAcmb+4ZKa4tV1IVQJLBVqOhaEfIESZzdwjmrQQ==",
+      "license": "MPL 2.0",
       "dependencies": {
-        "@mintlify/common": "1.0.779",
-        "@mintlify/prebuild": "1.0.917",
-        "@mintlify/validation": "0.1.626",
-        "better-opn": "3.0.2",
-        "chalk": "5.2.0",
-        "chokidar": "3.5.3",
-        "express": "4.18.2",
-        "front-matter": "4.0.2",
-        "fs-extra": "11.1.0",
-        "got": "13.0.0",
-        "ink": "6.3.0",
-        "ink-spinner": "5.0.0",
-        "is-online": "10.0.0",
-        "js-yaml": "4.1.0",
-        "openapi-types": "12.1.3",
-        "react": "19.2.3",
-        "socket.io": "4.7.2",
-        "tar": "6.1.15",
-        "unist-util-visit": "4.1.2",
-        "yargs": "17.7.1"
+        "@babel/code-frame": "^7.29.0",
+        "@mdx-js/mdx": "^3.1.1",
+        "@mdx-js/react": "^3.1.1",
+        "remark-mdx-remove-esm": "^1.3.1",
+        "serialize-error": "^13.0.1",
+        "vfile": "^6.0.3",
+        "vfile-matter": "^5.0.1"
       },
       "engines": {
-        "node": ">=18.0.0"
+        "node": ">=20.9.0"
+      },
+      "peerDependencies": {
+        "react": ">= 18.3.0 < 19.0.0",
+        "react-dom": ">= 18.3.0 < 19.0.0"
       }
     },
-    "node_modules/@mintlify/previewing/node_modules/@types/unist": {
-      "version": "2.0.11",
-      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
-      "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
-      "license": "MIT"
-    },
-    "node_modules/@mintlify/previewing/node_modules/fs-extra": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.0.tgz",
-      "integrity": "sha512-0rcTq621PD5jM/e0a3EJoGC/1TC5ZBCERW82LQuwfGnCa1V8w7dpYH1yNu+SLb6E5dkeCBzKEyLGlFrnr+dUyw==",
+    "node_modules/@mintlify/scraping/node_modules/react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "graceful-fs": "^4.2.0",
-        "jsonfile": "^6.0.1",
-        "universalify": "^2.0.0"
+        "loose-envify": "^1.1.0"
       },
       "engines": {
-        "node": ">=14.14"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/@mintlify/previewing/node_modules/unist-util-is": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz",
-      "integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==",
+    "node_modules/@mintlify/scraping/node_modules/react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@types/unist": "^2.0.0"
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
       },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+      "peerDependencies": {
+        "react": "^18.3.1"
       }
     },
-    "node_modules/@mintlify/previewing/node_modules/unist-util-visit": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz",
-      "integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==",
+    "node_modules/@mintlify/scraping/node_modules/remark-mdx": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.0.1.tgz",
+      "integrity": "sha512-3Pz3yPQ5Rht2pM5R+0J2MrGoBSrzf+tJG94N+t/ilfdh8YLyyKYtidAYwTveB20BoHAcwIopOUqhcmh2F7hGYA==",
       "license": "MIT",
       "dependencies": {
-        "@types/unist": "^2.0.0",
-        "unist-util-is": "^5.0.0",
-        "unist-util-visit-parents": "^5.1.1"
+        "mdast-util-mdx": "^3.0.0",
+        "micromark-extension-mdxjs": "^3.0.0"
       },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/@mintlify/previewing/node_modules/unist-util-visit-parents": {
-      "version": "5.1.3",
-      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz",
-      "integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==",
+    "node_modules/@mintlify/scraping/node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
-        "@types/unist": "^2.0.0",
-        "unist-util-is": "^5.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "loose-envify": "^1.1.0"
       }
     },
-    "node_modules/@mintlify/scraping": {
-      "version": "4.0.641",
-      "resolved": "https://registry.npmjs.org/@mintlify/scraping/-/scraping-4.0.641.tgz",
-      "integrity": "sha512-dAf7aebgj5HILzsP7xLXqf4RU3KgWyUIOA74CXOgxjbuNtdwIwYuQyn6M5v87ZYY2K+Lty5OUysL3h9P8E42Sw==",
-      "license": "Elastic-2.0",
+    "node_modules/@mintlify/scraping/node_modules/tailwindcss": {
+      "version": "3.4.4",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.4.tgz",
+      "integrity": "sha512-ZoyXOdJjISB7/BcLTR6SEsLgKtDStYyYZVLsUtWChO4Ps20CBad7lfJKVDiejocV4ME1hLmyY0WJE3hSDcmQ2A==",
+      "license": "MIT",
       "dependencies": {
-        "@mintlify/common": "1.0.779",
-        "@mintlify/openapi-parser": "^0.0.8",
-        "fs-extra": "11.1.1",
-        "hast-util-to-mdast": "10.1.0",
-        "js-yaml": "4.1.0",
-        "mdast-util-mdx-jsx": "3.1.3",
-        "neotraverse": "0.6.18",
-        "puppeteer": "22.14.0",
-        "rehype-parse": "9.0.1",
-        "remark-gfm": "4.0.0",
-        "remark-mdx": "3.0.1",
-        "remark-parse": "11.0.0",
-        "remark-stringify": "11.0.0",
-        "unified": "11.0.5",
-        "unist-util-visit": "5.0.0",
-        "yargs": "17.7.1",
-        "zod": "3.24.0"
+        "@alloc/quick-lru": "^5.2.0",
+        "arg": "^5.0.2",
+        "chokidar": "^3.5.3",
+        "didyoumean": "^1.2.2",
+        "dlv": "^1.1.3",
+        "fast-glob": "^3.3.0",
+        "glob-parent": "^6.0.2",
+        "is-glob": "^4.0.3",
+        "jiti": "^1.21.0",
+        "lilconfig": "^2.1.0",
+        "micromatch": "^4.0.5",
+        "normalize-path": "^3.0.0",
+        "object-hash": "^3.0.0",
+        "picocolors": "^1.0.0",
+        "postcss": "^8.4.23",
+        "postcss-import": "^15.1.0",
+        "postcss-js": "^4.0.1",
+        "postcss-load-config": "^4.0.1",
+        "postcss-nested": "^6.0.1",
+        "postcss-selector-parser": "^6.0.11",
+        "resolve": "^1.22.2",
+        "sucrase": "^3.32.0"
       },
       "bin": {
-        "mintlify-scrape": "bin/cli.js"
+        "tailwind": "lib/cli.js",
+        "tailwindcss": "lib/cli.js"
       },
       "engines": {
-        "node": ">=18.0.0"
+        "node": ">=14.0.0"
       }
     },
-    "node_modules/@mintlify/scraping/node_modules/fs-extra": {
-      "version": "11.1.1",
-      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.1.tgz",
-      "integrity": "sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==",
+    "node_modules/@mintlify/scraping/node_modules/tailwindcss/node_modules/postcss-load-config": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-4.0.2.tgz",
+      "integrity": "sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
       "license": "MIT",
       "dependencies": {
-        "graceful-fs": "^4.2.0",
-        "jsonfile": "^6.0.1",
-        "universalify": "^2.0.0"
+        "lilconfig": "^3.0.0",
+        "yaml": "^2.3.4"
       },
       "engines": {
-        "node": ">=14.14"
+        "node": ">= 14"
+      },
+      "peerDependencies": {
+        "postcss": ">=8.0.9",
+        "ts-node": ">=9.0.0"
+      },
+      "peerDependenciesMeta": {
+        "postcss": {
+          "optional": true
+        },
+        "ts-node": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@mintlify/scraping/node_modules/mdast-util-mdx-jsx": {
+    "node_modules/@mintlify/scraping/node_modules/tailwindcss/node_modules/postcss-load-config/node_modules/lilconfig": {
       "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.1.3.tgz",
-      "integrity": "sha512-bfOjvNt+1AcbPLTFMFWY149nJz0OjmewJs3LQQ5pIyVGxP4CdOqNVJL6kTaM5c68p8q82Xv3nCyFfUnuEcH3UQ==",
+      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
+      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
       "license": "MIT",
-      "dependencies": {
-        "@types/estree-jsx": "^1.0.0",
-        "@types/hast": "^3.0.0",
-        "@types/mdast": "^4.0.0",
-        "@types/unist": "^3.0.0",
-        "ccount": "^2.0.0",
-        "devlop": "^1.1.0",
-        "mdast-util-from-markdown": "^2.0.0",
-        "mdast-util-to-markdown": "^2.0.0",
-        "parse-entities": "^4.0.0",
-        "stringify-entities": "^4.0.0",
-        "unist-util-stringify-position": "^4.0.0",
-        "vfile-message": "^4.0.0"
+      "engines": {
+        "node": ">=14"
       },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/sponsors/antonk52"
       }
     },
-    "node_modules/@mintlify/scraping/node_modules/remark-mdx": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-3.0.1.tgz",
-      "integrity": "sha512-3Pz3yPQ5Rht2pM5R+0J2MrGoBSrzf+tJG94N+t/ilfdh8YLyyKYtidAYwTveB20BoHAcwIopOUqhcmh2F7hGYA==",
+    "node_modules/@mintlify/scraping/node_modules/zod": {
+      "version": "3.21.4",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.21.4.tgz",
+      "integrity": "sha512-m46AKbrzKVzOzs/DZgVnG5H55N1sv1M8qZU3A8RIKbs3mrACDNeIOeilDymVb2HdmP8uwshOCF4uJ8uM9rCqJw==",
       "license": "MIT",
-      "dependencies": {
-        "mdast-util-mdx": "^3.0.0",
-        "micromark-extension-mdxjs": "^3.0.0"
-      },
       "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/unified"
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@mintlify/scraping/node_modules/zod-to-json-schema": {
+      "version": "3.20.4",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.20.4.tgz",
+      "integrity": "sha512-Un9+kInJ2Zt63n6Z7mLqBifzzPcOyX+b+Exuzf7L1+xqck9Q2EPByyTRduV3kmSPaXaRer1JCsucubpgL1fipg==",
+      "license": "ISC",
+      "peerDependencies": {
+        "zod": "^3.20.0"
       }
     },
     "node_modules/@mintlify/validation": {
-      "version": "0.1.626",
-      "resolved": "https://registry.npmjs.org/@mintlify/validation/-/validation-0.1.626.tgz",
-      "integrity": "sha512-Ltn28sfiTzbBWlC/qhUDzWC80s9szhdg3p1YyhNulmI33zlvg5cyNQbty7CEgvZxGaATd17J+cS1peUVMCSYog==",
+      "version": "0.1.660",
+      "resolved": "https://registry.npmjs.org/@mintlify/validation/-/validation-0.1.660.tgz",
+      "integrity": "sha512-IHlea3t9ZZcQMOfext3fZuG6/hXXTZPBFJkgeHA9lbG2OkdAVRbSMDY9FvC07sEEX1VQJX+bPimRaXUz/ujyYg==",
       "license": "Elastic-2.0",
       "dependencies": {
         "@mintlify/mdx": "^3.0.4",
-        "@mintlify/models": "0.0.283",
+        "@mintlify/models": "0.0.290",
         "arktype": "2.1.27",
         "js-yaml": "4.1.0",
         "lcm": "0.0.3",
         "lodash": "4.17.21",
+        "neotraverse": "0.6.18",
         "object-hash": "3.0.0",
         "openapi-types": "12.1.3",
         "uuid": "11.1.0",
@@ -3282,15 +3481,15 @@
       }
     },
     "node_modules/@mintlify/validation/node_modules/next-mdx-remote-client": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/next-mdx-remote-client/-/next-mdx-remote-client-1.1.6.tgz",
-      "integrity": "sha512-O4HIpi44d6SismhfG5W78aTUfgxfbsj6FgoM4/G3o4Vtcobt0Ej439IiDPkv+IqsmtouVYG1tGAsz1DIuj9Tfg==",
+      "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/next-mdx-remote-client/-/next-mdx-remote-client-1.1.7.tgz",
+      "integrity": "sha512-12Ap5Z/tFIETMXFSBTH2IFEhJAso7MvOJ5ICyesA4q6FM4vtAcmb+4ZKa4tV1IVQJLBVqOhaEfIESZzdwjmrQQ==",
       "license": "MPL 2.0",
       "dependencies": {
         "@babel/code-frame": "^7.29.0",
         "@mdx-js/mdx": "^3.1.1",
         "@mdx-js/react": "^3.1.1",
-        "remark-mdx-remove-esm": "^1.2.3",
+        "remark-mdx-remove-esm": "^1.3.1",
         "serialize-error": "^13.0.1",
         "vfile": "^6.0.3",
         "vfile-matter": "^5.0.1"
@@ -3340,6 +3539,24 @@
         "loose-envify": "^1.1.0"
       }
     },
+    "node_modules/@mintlify/validation/node_modules/zod": {
+      "version": "3.24.0",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.0.tgz",
+      "integrity": "sha512-Hz+wiY8yD0VLA2k/+nsg2Abez674dDGTai33SwNvMPuf9uIrBC9eFgIMQxBBbHFxVXi8W+5nX9DcAh9YNSQm/w==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@mintlify/validation/node_modules/zod-to-json-schema": {
+      "version": "3.20.4",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.20.4.tgz",
+      "integrity": "sha512-Un9+kInJ2Zt63n6Z7mLqBifzzPcOyX+b+Exuzf7L1+xqck9Q2EPByyTRduV3kmSPaXaRer1JCsucubpgL1fipg==",
+      "license": "ISC",
+      "peerDependencies": {
+        "zod": "^3.20.0"
+      }
+    },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -3384,6 +3601,15 @@
         "fast-deep-equal": "^3.1.3"
       }
     },
+    "node_modules/@posthog/core": {
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/@posthog/core/-/core-1.7.1.tgz",
+      "integrity": "sha512-kjK0eFMIpKo9GXIbts8VtAknsoZ18oZorANdtuTj1CbgS28t4ZVq//HAWhnxEuXRTrtkd+SUJ6Ux3j2Af8NCuA==",
+      "license": "MIT",
+      "dependencies": {
+        "cross-spawn": "^7.0.6"
+      }
+    },
     "node_modules/@puppeteer/browsers": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.3.0.tgz",
@@ -3456,6 +3682,32 @@
         "node": ">=8"
       }
     },
+    "node_modules/@puppeteer/browsers/node_modules/tar-fs": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.2.tgz",
+      "integrity": "sha512-QGxxTxxyleAdyM3kpFs14ymbYmNFrfY+pHj7Z8FgtbZ7w2//VAgLMac7sT6nRpIHjppXO2AwwEOg0bPFVRcmXw==",
+      "license": "MIT",
+      "dependencies": {
+        "pump": "^3.0.0",
+        "tar-stream": "^3.1.5"
+      },
+      "optionalDependencies": {
+        "bare-fs": "^4.0.1",
+        "bare-path": "^3.0.0"
+      }
+    },
+    "node_modules/@puppeteer/browsers/node_modules/tar-stream": {
+      "version": "3.1.8",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.8.tgz",
+      "integrity": "sha512-U6QpVRyCGHva435KoNWy9PRoi2IFYCgtEhq9nmrPPpbRacPs9IH4aJ3gbrFC8dPcXvdSZ4XXfXT5Fshbp2MtlQ==",
+      "license": "MIT",
+      "dependencies": {
+        "b4a": "^1.6.4",
+        "bare-fs": "^4.5.5",
+        "fast-fifo": "^1.2.0",
+        "streamx": "^2.15.0"
+      }
+    },
     "node_modules/@puppeteer/browsers/node_modules/yargs": {
       "version": "17.7.2",
       "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
@@ -4267,9 +4519,9 @@
       }
     },
     "node_modules/@types/debug": {
-      "version": "4.1.12",
-      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz",
-      "integrity": "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==",
+      "version": "4.1.13",
+      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.13.tgz",
+      "integrity": "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==",
       "license": "MIT",
       "dependencies": {
         "@types/ms": "*"
@@ -4357,9 +4609,9 @@
       }
     },
     "node_modules/@types/node": {
-      "version": "25.3.5",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.3.5.tgz",
-      "integrity": "sha512-oX8xrhvpiyRCQkG1MFchB09f+cXftgIXb3a7UUa4Y3wpmZPw5tyZGTLWhlESOLq1Rq6oDlc8npVU2/9xiCuXMA==",
+      "version": "25.5.2",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.5.2.tgz",
+      "integrity": "sha512-tO4ZIRKNC+MDWV4qKVZe3Ql/woTnmHDr5JD8UI5hn2pwBrHEwOEMZK7WlNb5RKB6EoJ02gwmQS9OrjuFnZYdpg==",
       "license": "MIT",
       "dependencies": {
         "undici-types": "~7.18.0"
@@ -4857,9 +5109,9 @@
       }
     },
     "node_modules/bare-fs": {
-      "version": "4.5.5",
-      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.5.5.tgz",
-      "integrity": "sha512-XvwYM6VZqKoqDll8BmSww5luA5eflDzY0uEFfBJtFKe4PAAtxBjU3YIxzIBzhyaEQBy1VXEQBto4cpN5RZJw+w==",
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.6.0.tgz",
+      "integrity": "sha512-2YkS7NuiJceSEbyEOdSNLE9tsGd+f4+f7C+Nik/MCk27SYdwIMPT/yRKvg++FZhQXgk0KWJKJyXX9RhVV0RGqA==",
       "license": "Apache-2.0",
       "dependencies": {
         "bare-events": "^2.5.4",
@@ -4881,9 +5133,9 @@
       }
     },
     "node_modules/bare-os": {
-      "version": "3.7.1",
-      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.7.1.tgz",
-      "integrity": "sha512-ebvMaS5BgZKmJlvuWh14dg9rbUI84QeV3WlWn6Ph6lFI8jJoh7ADtVTyD2c93euwbe+zgi0DVrl4YmqXeM9aIA==",
+      "version": "3.8.7",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.8.7.tgz",
+      "integrity": "sha512-G4Gr1UsGeEy2qtDTZwL7JFLo2wapUarz7iTMcYcMFdS89AIQuBoyjgXZz0Utv7uHs3xA9LckhVbeBi8lEQrC+w==",
       "license": "Apache-2.0",
       "engines": {
         "bare": ">=1.14.0"
@@ -4899,19 +5151,23 @@
       }
     },
     "node_modules/bare-stream": {
-      "version": "2.8.0",
-      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.8.0.tgz",
-      "integrity": "sha512-reUN0M2sHRqCdG4lUK3Fw8w98eeUIZHL5c3H7Mbhk2yVBL+oofgaIp0ieLfD5QXwPCypBpmEEKU2WZKzbAk8GA==",
+      "version": "2.12.0",
+      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.12.0.tgz",
+      "integrity": "sha512-w28i8lkBgREV3rPXGbgK+BO66q+ZpKqRWrZLiCdmmUlLPrQ45CzkvRhN+7lnv00Gpi2zy5naRxnUFAxCECDm9g==",
       "license": "Apache-2.0",
       "dependencies": {
-        "streamx": "^2.21.0",
+        "streamx": "^2.25.0",
         "teex": "^1.0.1"
       },
       "peerDependencies": {
+        "bare-abort-controller": "*",
         "bare-buffer": "*",
         "bare-events": "*"
       },
       "peerDependenciesMeta": {
+        "bare-abort-controller": {
+          "optional": true
+        },
         "bare-buffer": {
           "optional": true
         },
@@ -4921,9 +5177,9 @@
       }
     },
     "node_modules/bare-url": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/bare-url/-/bare-url-2.3.2.tgz",
-      "integrity": "sha512-ZMq4gd9ngV5aTMa5p9+UfY0b3skwhHELaDkhEHetMdX0LRkW9kzaym4oo/Eh+Ghm0CCDuMTsRIGM/ytUc1ZYmw==",
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/bare-url/-/bare-url-2.4.0.tgz",
+      "integrity": "sha512-NSTU5WN+fy/L0DDenfE8SXQna4voXuW0FHM7wH8i3/q9khUSchfPbPezO4zSFMnDGIf9YE+mt/RWhZgNRKRIXA==",
       "license": "Apache-2.0",
       "dependencies": {
         "bare-path": "^3.0.0"
@@ -4959,9 +5215,9 @@
       }
     },
     "node_modules/basic-ftp": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.2.0.tgz",
-      "integrity": "sha512-VoMINM2rqJwJgfdHq6RiUudKt2BV+FY5ZFezP/ypmwayk68+NzzAQy4XXLlqsGD4MCzq3DrmNFD/uUmBJuGoXw==",
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.2.2.tgz",
+      "integrity": "sha512-1tDrzKsdCg70WGvbFss/ulVAxupNauGnOlgpyjKzeQxzyllBLS0CGLV7tjIXTK3ZQA9/FBEm9qyFFN1bciA6pw==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"
@@ -4991,6 +5247,18 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/bl": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
+      "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "buffer": "^5.5.0",
+        "inherits": "^2.0.4",
+        "readable-stream": "^3.4.0"
+      }
+    },
     "node_modules/body-parser": {
       "version": "1.20.1",
       "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.1.tgz",
@@ -5043,9 +5311,9 @@
       "license": "MIT"
     },
     "node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "version": "1.1.13",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+      "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
       "license": "MIT",
       "dependencies": {
         "balanced-match": "^1.0.0",
@@ -5725,6 +5993,20 @@
         }
       }
     },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/cssesc": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
@@ -5894,6 +6176,16 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/deep-extend": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz",
+      "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
     "node_modules/defer-to-connect": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz",
@@ -6255,9 +6547,9 @@
       }
     },
     "node_modules/es-abstract": {
-      "version": "1.24.1",
-      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.1.tgz",
-      "integrity": "sha512-zHXBLhP+QehSSbsS9Pt23Gg964240DPd6QCf8WpkqEXxQ7fhdZzYsocOr5u7apWonsS5EjZDmTF+/slGMyasvw==",
+      "version": "1.24.2",
+      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.2.tgz",
+      "integrity": "sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg==",
       "license": "MIT",
       "dependencies": {
         "array-buffer-byte-length": "^1.0.2",
@@ -6655,6 +6947,16 @@
         "bare-events": "^2.7.0"
       }
     },
+    "node_modules/expand-template": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz",
+      "integrity": "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==",
+      "license": "(MIT OR WTFPL)",
+      "optional": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/express": {
       "version": "4.18.2",
       "resolved": "https://registry.npmjs.org/express/-/express-4.18.2.tgz",
@@ -6922,6 +7224,9 @@
       "cpu": [
         "arm"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -6938,6 +7243,9 @@
       "cpu": [
         "arm64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -6954,6 +7262,9 @@
       "cpu": [
         "s390x"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -6970,6 +7281,9 @@
       "cpu": [
         "x64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -6986,6 +7300,9 @@
       "cpu": [
         "arm64"
       ],
+      "libc": [
+        "musl"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -7002,6 +7319,9 @@
       "cpu": [
         "x64"
       ],
+      "libc": [
+        "musl"
+      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -7018,6 +7338,9 @@
       "cpu": [
         "arm"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -7040,6 +7363,9 @@
       "cpu": [
         "arm64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -7062,6 +7388,9 @@
       "cpu": [
         "s390x"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -7084,6 +7413,9 @@
       "cpu": [
         "x64"
       ],
+      "libc": [
+        "glibc"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -7106,6 +7438,9 @@
       "cpu": [
         "arm64"
       ],
+      "libc": [
+        "musl"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -7128,6 +7463,9 @@
       "cpu": [
         "x64"
       ],
+      "libc": [
+        "musl"
+      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -7410,6 +7748,13 @@
         "js-yaml": "bin/js-yaml.js"
       }
     },
+    "node_modules/fs-constants": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
+      "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==",
+      "license": "MIT",
+      "optional": true
+    },
     "node_modules/fs-extra": {
       "version": "11.2.0",
       "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.2.0.tgz",
@@ -7626,6 +7971,13 @@
         "node": ">= 14"
       }
     },
+    "node_modules/github-from-package": {
+      "version": "0.0.0",
+      "resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz",
+      "integrity": "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==",
+      "license": "MIT",
+      "optional": true
+    },
     "node_modules/glob-parent": {
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
@@ -8295,6 +8647,13 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "license": "ISC"
     },
+    "node_modules/ini": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==",
+      "license": "ISC",
+      "optional": true
+    },
     "node_modules/ink": {
       "version": "6.3.0",
       "resolved": "https://registry.npmjs.org/ink/-/ink-6.3.0.tgz",
@@ -9047,6 +9406,12 @@
       "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
       "license": "MIT"
     },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "license": "ISC"
+    },
     "node_modules/jiti": {
       "version": "1.21.7",
       "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
@@ -9056,6 +9421,15 @@
         "jiti": "bin/jiti.js"
       }
     },
+    "node_modules/jose": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.2.tgz",
+      "integrity": "sha512-d7kPDd34KO/YnzaDOlikGpOurfF0ByC2sEV4cANCtdqLlTfBlw2p14O/5d/zv40gJPbIQxfES3nSx1/oYNyuZQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
     "node_modules/js-tokens": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
@@ -9147,9 +9521,9 @@
       }
     },
     "node_modules/katex": {
-      "version": "0.16.35",
-      "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.35.tgz",
-      "integrity": "sha512-S0+riEvy1CK4VKse1ivMff8gmabe/prY7sKB3njjhyoLLsNFDQYtKNgXrbWUggGDCJBz7Fctl5i8fLCESHXzSg==",
+      "version": "0.16.45",
+      "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.45.tgz",
+      "integrity": "sha512-pQpZbdBu7wCTmQUh7ufPmLr0pFoObnGUoL/yhtwJDgmmQpbkg/0HSVti25Fu4rmd1oCR6NGWe9vqTWuWv3GcNA==",
       "funding": [
         "https://opencollective.com/katex",
         "https://github.com/sponsors/katex"
@@ -9162,6 +9536,18 @@
         "katex": "cli.js"
       }
     },
+    "node_modules/keytar": {
+      "version": "7.9.0",
+      "resolved": "https://registry.npmjs.org/keytar/-/keytar-7.9.0.tgz",
+      "integrity": "sha512-VPD8mtVtm5JNtA2AErl6Chp06JBfy7diFQ7TQQhdpWOl6MrCRB+eRbvAZUsbGQS9kiMq0coJsy0W0vHpDCkWsQ==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "node-addon-api": "^4.3.0",
+        "prebuild-install": "^7.0.1"
+      }
+    },
     "node_modules/keyv": {
       "version": "4.5.4",
       "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
@@ -9193,12 +9579,15 @@
       }
     },
     "node_modules/lilconfig": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz",
-      "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==",
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
+      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
       "license": "MIT",
       "engines": {
-        "node": ">=10"
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antonk52"
       }
     },
     "node_modules/lines-and-columns": {
@@ -10483,6 +10872,16 @@
         "node": "*"
       }
     },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "license": "MIT",
+      "optional": true,
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/minipass": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz",
@@ -10518,12 +10917,12 @@
       }
     },
     "node_modules/mintlify": {
-      "version": "4.2.408",
-      "resolved": "https://registry.npmjs.org/mintlify/-/mintlify-4.2.408.tgz",
-      "integrity": "sha512-QYm58iawvBv5L0EjasPEXnsaF6I0KCZS3/tKwNA6X62AfjoKpxuJowSJZjGznGCPuITyF13bOfK91OYs5Z3tnA==",
+      "version": "4.2.500",
+      "resolved": "https://registry.npmjs.org/mintlify/-/mintlify-4.2.500.tgz",
+      "integrity": "sha512-pVuzf4F+JRmVCuQZLQebIlggCzWQyHsnPiAbuUoJ8aofsKbbs30woRQznoeCmzgmzDxBk25xPay9yy4GRPRlOw==",
       "license": "Elastic-2.0",
       "dependencies": {
-        "@mintlify/cli": "4.0.1011"
+        "@mintlify/cli": "4.0.1103"
       },
       "bin": {
         "mintlify": "index.js"
@@ -10550,6 +10949,13 @@
         "node": ">=10"
       }
     },
+    "node_modules/mkdirp-classic": {
+      "version": "0.5.3",
+      "resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz",
+      "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==",
+      "license": "MIT",
+      "optional": true
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -10594,6 +11000,13 @@
         "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
       }
     },
+    "node_modules/napi-build-utils": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/napi-build-utils/-/napi-build-utils-2.0.0.tgz",
+      "integrity": "sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==",
+      "license": "MIT",
+      "optional": true
+    },
     "node_modules/negotiator": {
       "version": "0.6.3",
       "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
@@ -10613,9 +11026,9 @@
       }
     },
     "node_modules/netmask": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/netmask/-/netmask-2.0.2.tgz",
-      "integrity": "sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==",
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/netmask/-/netmask-2.1.0.tgz",
+      "integrity": "sha512-z9sZrk6wyf8/NDKKqe+Tyl58XtgkYrV4kgt1O8xrzYvpl1LvPacPo0imMLHfpStk3kgCIq1ksJ2bmJn9hue2lQ==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.4.0"
@@ -10653,6 +11066,26 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/node-abi": {
+      "version": "3.89.0",
+      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.89.0.tgz",
+      "integrity": "sha512-6u9UwL0HlAl21+agMN3YAMXcKByMqwGx+pq+P76vii5f7hTPtKDp08/H9py6DY+cfDw7kQNTGEj/rly3IgbNQA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "semver": "^7.3.5"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/node-addon-api": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-4.3.0.tgz",
+      "integrity": "sha512-73sE9+3UaLYYFmDsFZnqCInzPyh3MqIwZO9cw58yIqAZhONrrabrYyYe3TuIqtIiOuTXVhsGau8hcrhhwSsDIQ==",
+      "license": "MIT",
+      "optional": true
+    },
     "node_modules/node-fetch": {
       "version": "2.6.7",
       "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz",
@@ -10706,6 +11139,15 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/oauth4webapi": {
+      "version": "3.8.5",
+      "resolved": "https://registry.npmjs.org/oauth4webapi/-/oauth4webapi-3.8.5.tgz",
+      "integrity": "sha512-A8jmyUckVhRJj5lspguklcl90Ydqk61H3dcU0oLhH3Yv13KpAliKTt5hknpGGPZSSfOwGyraNEFmofDYH+1kSg==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
     "node_modules/object-assign": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
@@ -10808,13 +11250,13 @@
       "license": "MIT"
     },
     "node_modules/oniguruma-to-es": {
-      "version": "4.3.4",
-      "resolved": "https://registry.npmjs.org/oniguruma-to-es/-/oniguruma-to-es-4.3.4.tgz",
-      "integrity": "sha512-3VhUGN3w2eYxnTzHn+ikMI+fp/96KoRSVK9/kMTcFqj1NRDh2IhQCKvYxDnWePKRXY/AqH+Fuiyb7VHSzBjHfA==",
+      "version": "4.3.5",
+      "resolved": "https://registry.npmjs.org/oniguruma-to-es/-/oniguruma-to-es-4.3.5.tgz",
+      "integrity": "sha512-Zjygswjpsewa0NLTsiizVuMQZbp0MDyM6lIt66OxsF21npUDlzpHi1Mgb/qhQdkb+dWFTzJmFbEWdvZgRho8eQ==",
       "license": "MIT",
       "dependencies": {
         "oniguruma-parser": "^0.12.1",
-        "regex": "^6.0.1",
+        "regex": "^6.1.0",
         "regex-recursion": "^6.0.2"
       }
     },
@@ -10841,6 +11283,19 @@
       "integrity": "sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw==",
       "license": "MIT"
     },
+    "node_modules/openid-client": {
+      "version": "6.8.2",
+      "resolved": "https://registry.npmjs.org/openid-client/-/openid-client-6.8.2.tgz",
+      "integrity": "sha512-uOvTCndr4udZsKihJ68H9bUICrriHdUVJ6Az+4Ns6cW55rwM5h0bjVIzDz2SxgOI84LKjFyjOFvERLzdTUROGA==",
+      "license": "MIT",
+      "dependencies": {
+        "jose": "^6.1.3",
+        "oauth4webapi": "^3.8.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
     "node_modules/own-keys": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz",
@@ -11046,6 +11501,15 @@
         "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       }
     },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/path-parse": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
@@ -11071,9 +11535,9 @@
       "license": "ISC"
     },
     "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
       "license": "MIT",
       "engines": {
         "node": ">=8.6"
@@ -11189,9 +11653,9 @@
       }
     },
     "node_modules/postcss-load-config": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-4.0.2.tgz",
-      "integrity": "sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz",
+      "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==",
       "funding": [
         {
           "type": "opencollective",
@@ -11204,37 +11668,32 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "lilconfig": "^3.0.0",
-        "yaml": "^2.3.4"
+        "lilconfig": "^3.1.1"
       },
       "engines": {
-        "node": ">= 14"
+        "node": ">= 18"
       },
       "peerDependencies": {
+        "jiti": ">=1.21.0",
         "postcss": ">=8.0.9",
-        "ts-node": ">=9.0.0"
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
       },
       "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        },
         "postcss": {
           "optional": true
         },
-        "ts-node": {
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
           "optional": true
         }
       }
     },
-    "node_modules/postcss-load-config/node_modules/lilconfig": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
-      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/antonk52"
-      }
-    },
     "node_modules/postcss-nested": {
       "version": "6.2.0",
       "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz",
@@ -11279,6 +11738,46 @@
       "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
       "license": "MIT"
     },
+    "node_modules/posthog-node": {
+      "version": "5.17.2",
+      "resolved": "https://registry.npmjs.org/posthog-node/-/posthog-node-5.17.2.tgz",
+      "integrity": "sha512-lz3YJOr0Nmiz0yHASaINEDHqoV+0bC3eD8aZAG+Ky292dAnVYul+ga/dMX8KCBXg8hHfKdxw0SztYD5j6dgUqQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@posthog/core": "1.7.1"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/prebuild-install": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.3.tgz",
+      "integrity": "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==",
+      "deprecated": "No longer maintained. Please contact the author of the relevant native addon; alternatives are available.",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "detect-libc": "^2.0.0",
+        "expand-template": "^2.0.3",
+        "github-from-package": "0.0.0",
+        "minimist": "^1.2.3",
+        "mkdirp-classic": "^0.5.3",
+        "napi-build-utils": "^2.0.0",
+        "node-abi": "^3.3.0",
+        "pump": "^3.0.0",
+        "rc": "^1.2.7",
+        "simple-get": "^4.0.0",
+        "tar-fs": "^2.0.0",
+        "tunnel-agent": "^0.6.0"
+      },
+      "bin": {
+        "prebuild-install": "bin.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/progress": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
@@ -11507,6 +12006,22 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/rc": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz",
+      "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==",
+      "license": "(BSD-2-Clause OR MIT OR Apache-2.0)",
+      "optional": true,
+      "dependencies": {
+        "deep-extend": "^0.6.0",
+        "ini": "~1.3.0",
+        "minimist": "^1.2.0",
+        "strip-json-comments": "~2.0.1"
+      },
+      "bin": {
+        "rc": "cli.js"
+      }
+    },
     "node_modules/react": {
       "version": "19.2.3",
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
@@ -11633,6 +12148,21 @@
         "pify": "^2.3.0"
       }
     },
+    "node_modules/readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/readdirp": {
       "version": "3.6.0",
       "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
@@ -11937,9 +12467,9 @@
       }
     },
     "node_modules/remark-mdx-remove-esm": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/remark-mdx-remove-esm/-/remark-mdx-remove-esm-1.2.3.tgz",
-      "integrity": "sha512-n6r36SaE+7cno7pmshWbGzYolDVLxJm5EKuw67+q4SPQT6kelNJHyZAiFYYtOB0axh+/1xF4BC57Ec3jncAGXQ==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/remark-mdx-remove-esm/-/remark-mdx-remove-esm-1.3.1.tgz",
+      "integrity": "sha512-POa8abdiuicD2e+zQkclxzJa5JEGLtV8XIOFVvisnGuw4l4xd6dfQozedwqR8JTeXQmxLebvYhlbwHoQP9RWkw==",
       "license": "MIT",
       "dependencies": {
         "@types/mdast": "^4.0.4",
@@ -12306,9 +12836,9 @@
       "license": "MIT"
     },
     "node_modules/sax": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/sax/-/sax-1.5.0.tgz",
-      "integrity": "sha512-21IYA3Q5cQf089Z6tgaUTr7lDAyzoTPx5HRtbhsME8Udispad8dC/+sziTNugOEx54ilvatQ9YCzl4KQLPcRHA==",
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz",
+      "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==",
       "license": "BlueOak-1.0.0",
       "engines": {
         "node": ">=11.0.0"
@@ -12388,9 +12918,9 @@
       }
     },
     "node_modules/serialize-error/node_modules/type-fest": {
-      "version": "5.4.4",
-      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.4.4.tgz",
-      "integrity": "sha512-JnTrzGu+zPV3aXIUhnyWJj4z/wigMsdYajGLIYakqyOW1nPllzXEJee0QQbHj+CTIQtXGlAjuK0UY+2xTyjVAw==",
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.5.0.tgz",
+      "integrity": "sha512-PlBfpQwiUvGViBNX84Yxwjsdhd1TUlXr6zjX7eoirtCPIr08NAmxwa+fcYBTeRQxHo9YC9wwF3m9i700sHma8g==",
       "license": "(MIT OR CC0-1.0)",
       "dependencies": {
         "tagged-tag": "^1.0.0"
@@ -12525,9 +13055,9 @@
       }
     },
     "node_modules/sharp/node_modules/semver": {
-      "version": "7.7.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
-      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
       "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
@@ -12536,6 +13066,27 @@
         "node": ">=10"
       }
     },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/shiki": {
       "version": "3.23.0",
       "resolved": "https://registry.npmjs.org/shiki/-/shiki-3.23.0.tgz",
@@ -12636,6 +13187,27 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/simple-concat": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz",
+      "integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "optional": true
+    },
     "node_modules/simple-eval": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/simple-eval/-/simple-eval-1.0.1.tgz",
@@ -12648,6 +13220,32 @@
         "node": ">=12"
       }
     },
+    "node_modules/simple-get": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-4.0.1.tgz",
+      "integrity": "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "decompress-response": "^6.0.0",
+        "once": "^1.3.1",
+        "simple-concat": "^1.0.0"
+      }
+    },
     "node_modules/simple-swizzle": {
       "version": "0.2.4",
       "resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.4.tgz",
@@ -12739,9 +13337,9 @@
       }
     },
     "node_modules/socket.io-parser": {
-      "version": "4.2.5",
-      "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-4.2.5.tgz",
-      "integrity": "sha512-bPMmpy/5WWKHea5Y/jYAP6k74A+hvmRCQaJuJB6I/ML5JZq/KfNieUVo/3Mh7SAqn7TyFdIo6wqYHInG1MU1bQ==",
+      "version": "4.2.6",
+      "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-4.2.6.tgz",
+      "integrity": "sha512-asJqbVBDsBCJx0pTqw3WfesSY0iRX+2xzWEWzrpcH7L6fLzrhyF8WPI8UaeM4YCuDfpwA/cgsdugMsmtz8EJeg==",
       "license": "MIT",
       "dependencies": {
         "@socket.io/component-emitter": "~3.1.0",
@@ -12874,9 +13472,9 @@
       }
     },
     "node_modules/streamx": {
-      "version": "2.23.0",
-      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.23.0.tgz",
-      "integrity": "sha512-kn+e44esVfn2Fa/O0CPFcex27fjIL6MkVae0Mm6q+E6f0hWv578YCERbv+4m02cjxvDsPKLnmxral/rR6lBMAg==",
+      "version": "2.25.0",
+      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.25.0.tgz",
+      "integrity": "sha512-0nQuG6jf1w+wddNEEXCF4nTg3LtufWINB5eFEN+5TNZW7KWJp6x87+JFL43vaAUPyCfH1wID+mNVyW6OHtFamg==",
       "license": "MIT",
       "dependencies": {
         "events-universal": "^1.0.0",
@@ -12884,6 +13482,16 @@
         "text-decoder": "^1.1.0"
       }
     },
+    "node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
     "node_modules/string-width": {
       "version": "7.2.0",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
@@ -12986,6 +13594,16 @@
         "url": "https://github.com/chalk/strip-ansi?sponsor=1"
       }
     },
+    "node_modules/strip-json-comments": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+      "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/style-to-js": {
       "version": "1.1.21",
       "resolved": "https://registry.npmjs.org/style-to-js/-/style-to-js-1.1.21.tgz",
@@ -13060,33 +13678,33 @@
       }
     },
     "node_modules/tailwindcss": {
-      "version": "3.4.4",
-      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.4.tgz",
-      "integrity": "sha512-ZoyXOdJjISB7/BcLTR6SEsLgKtDStYyYZVLsUtWChO4Ps20CBad7lfJKVDiejocV4ME1hLmyY0WJE3hSDcmQ2A==",
+      "version": "3.4.19",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz",
+      "integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==",
       "license": "MIT",
       "dependencies": {
         "@alloc/quick-lru": "^5.2.0",
         "arg": "^5.0.2",
-        "chokidar": "^3.5.3",
+        "chokidar": "^3.6.0",
         "didyoumean": "^1.2.2",
         "dlv": "^1.1.3",
-        "fast-glob": "^3.3.0",
+        "fast-glob": "^3.3.2",
         "glob-parent": "^6.0.2",
         "is-glob": "^4.0.3",
-        "jiti": "^1.21.0",
-        "lilconfig": "^2.1.0",
-        "micromatch": "^4.0.5",
+        "jiti": "^1.21.7",
+        "lilconfig": "^3.1.3",
+        "micromatch": "^4.0.8",
         "normalize-path": "^3.0.0",
         "object-hash": "^3.0.0",
-        "picocolors": "^1.0.0",
-        "postcss": "^8.4.23",
+        "picocolors": "^1.1.1",
+        "postcss": "^8.4.47",
         "postcss-import": "^15.1.0",
         "postcss-js": "^4.0.1",
-        "postcss-load-config": "^4.0.1",
-        "postcss-nested": "^6.0.1",
-        "postcss-selector-parser": "^6.0.11",
-        "resolve": "^1.22.2",
-        "sucrase": "^3.32.0"
+        "postcss-load-config": "^4.0.2 || ^5.0 || ^6.0",
+        "postcss-nested": "^6.2.0",
+        "postcss-selector-parser": "^6.1.2",
+        "resolve": "^1.22.8",
+        "sucrase": "^3.35.0"
       },
       "bin": {
         "tailwind": "lib/cli.js",
@@ -13096,6 +13714,42 @@
         "node": ">=14.0.0"
       }
     },
+    "node_modules/tailwindcss/node_modules/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "license": "MIT",
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/tailwindcss/node_modules/chokidar/node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/tailwindcss/node_modules/glob-parent": {
       "version": "6.0.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
@@ -13127,29 +13781,40 @@
       }
     },
     "node_modules/tar-fs": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.2.tgz",
-      "integrity": "sha512-QGxxTxxyleAdyM3kpFs14ymbYmNFrfY+pHj7Z8FgtbZ7w2//VAgLMac7sT6nRpIHjppXO2AwwEOg0bPFVRcmXw==",
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.4.tgz",
+      "integrity": "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==",
       "license": "MIT",
+      "optional": true,
       "dependencies": {
+        "chownr": "^1.1.1",
+        "mkdirp-classic": "^0.5.2",
         "pump": "^3.0.0",
-        "tar-stream": "^3.1.5"
-      },
-      "optionalDependencies": {
-        "bare-fs": "^4.0.1",
-        "bare-path": "^3.0.0"
+        "tar-stream": "^2.1.4"
       }
     },
+    "node_modules/tar-fs/node_modules/chownr": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz",
+      "integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==",
+      "license": "ISC",
+      "optional": true
+    },
     "node_modules/tar-stream": {
-      "version": "3.1.8",
-      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.8.tgz",
-      "integrity": "sha512-U6QpVRyCGHva435KoNWy9PRoi2IFYCgtEhq9nmrPPpbRacPs9IH4aJ3gbrFC8dPcXvdSZ4XXfXT5Fshbp2MtlQ==",
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz",
+      "integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==",
       "license": "MIT",
+      "optional": true,
       "dependencies": {
-        "b4a": "^1.6.4",
-        "bare-fs": "^4.5.5",
-        "fast-fifo": "^1.2.0",
-        "streamx": "^2.15.0"
+        "bl": "^4.0.3",
+        "end-of-stream": "^1.4.1",
+        "fs-constants": "^1.0.0",
+        "inherits": "^2.0.3",
+        "readable-stream": "^3.1.1"
+      },
+      "engines": {
+        "node": ">=6"
       }
     },
     "node_modules/teex": {
@@ -13198,13 +13863,13 @@
       "license": "MIT"
     },
     "node_modules/tinyglobby": {
-      "version": "0.2.15",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
-      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "version": "0.2.16",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz",
+      "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==",
       "license": "MIT",
       "dependencies": {
         "fdir": "^6.5.0",
-        "picomatch": "^4.0.3"
+        "picomatch": "^4.0.4"
       },
       "engines": {
         "node": ">=12.0.0"
@@ -13231,9 +13896,9 @@
       }
     },
     "node_modules/tinyglobby/node_modules/picomatch": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
-      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
       "license": "MIT",
       "engines": {
         "node": ">=12"
@@ -13317,6 +13982,19 @@
       "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
       "license": "0BSD"
     },
+    "node_modules/tunnel-agent": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz",
+      "integrity": "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "dependencies": {
+        "safe-buffer": "^5.0.1"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/twoslash": {
       "version": "0.3.6",
       "resolved": "https://registry.npmjs.org/twoslash/-/twoslash-0.3.6.tgz",
@@ -13896,6 +14574,21 @@
         "webidl-conversions": "^3.0.0"
       }
     },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/which-boxed-primitive": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz",
@@ -14082,9 +14775,9 @@
       "license": "ISC"
     },
     "node_modules/ws": {
-      "version": "8.19.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
-      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
+      "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"
@@ -14162,9 +14855,9 @@
       "license": "ISC"
     },
     "node_modules/yaml": {
-      "version": "2.8.2",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.2.tgz",
-      "integrity": "sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==",
+      "version": "2.8.3",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.3.tgz",
+      "integrity": "sha512-AvbaCLOO2Otw/lW5bmh9d/WEdcDFdQp2Z2ZUH3pX9U2ihyUY0nvLv7J6TrWowklRGPYbB/IuIMfYgxaCPg5Bpg==",
       "license": "ISC",
       "bin": {
         "yaml": "bin.mjs"
@@ -14282,23 +14975,14 @@
       "license": "MIT"
     },
     "node_modules/zod": {
-      "version": "3.24.0",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.0.tgz",
-      "integrity": "sha512-Hz+wiY8yD0VLA2k/+nsg2Abez674dDGTai33SwNvMPuf9uIrBC9eFgIMQxBBbHFxVXi8W+5nX9DcAh9YNSQm/w==",
+      "version": "4.3.6",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz",
+      "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
       }
     },
-    "node_modules/zod-to-json-schema": {
-      "version": "3.20.4",
-      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.20.4.tgz",
-      "integrity": "sha512-Un9+kInJ2Zt63n6Z7mLqBifzzPcOyX+b+Exuzf7L1+xqck9Q2EPByyTRduV3kmSPaXaRer1JCsucubpgL1fipg==",
-      "license": "ISC",
-      "peerDependencies": {
-        "zod": "^3.20.0"
-      }
-    },
     "node_modules/zwitch": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
diff --git a/docs/package.json b/docs/package.json
index e7e35ce3251..4413f7c935b 100644
--- a/docs/package.json
+++ b/docs/package.json
@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "mintlify": "^4.2.408",
+    "mintlify": "^4.2.500",
     "sharp": "^0.34.4"
   }
 }
diff --git a/docs/rest/sql.mdx b/docs/rest/sql.mdx
index 0a8d5bd0f5b..4b8604931d0 100644
--- a/docs/rest/sql.mdx
+++ b/docs/rest/sql.mdx
@@ -20,6 +20,29 @@ String that contains the SQL query that needs to be executed.
 
 </ParamField>
 
+<ParamField body='response_format' type='string'>
+
+Format of the response. Available options:
+- `null` (default) - returns all data in a single JSON response
+- `"sse"` - returns data as Server-Sent Events stream
+- `"jsonlines"` - returns data as JSON Lines stream (one JSON object per line)
+
+Use `"sse"` or `"jsonlines"` for streaming large result sets to avoid loading all data into memory at once.
+
+</ParamField>
+
+<ParamField body='context' type='object'>
+
+Optional context object, e.g., `{"db": "mindsdb"}` to specify the database.
+
+</ParamField>
+
+<ParamField body='params' type='object'>
+
+Optional parameters for parameterized queries, e.g., `{"name": "value"}`.
+
+</ParamField>
+
 ### Response
 
 <ResponseField name="column_names" type="array" required>  
@@ -55,9 +78,32 @@ curl --request POST \
 {
      "query": "SELECT * FROM example_db.demo_data.home_rentals LIMIT 10;"
 }
+'
+```
 
+```shell Shell (Streaming with SSE)
+curl --request POST \
+     --url https://cloud.mindsdb.com/api/sql/query \
+     --header 'Content-Type: application/json' \
+     --data '
+{
+     "query": "SELECT * FROM example_db.demo_data.home_rentals;",
+     "response_format": "sse"
+}
+'
 ```
 
+```shell Shell (Streaming with JSON Lines)
+curl --request POST \
+     --url https://cloud.mindsdb.com/api/sql/query \
+     --header 'Content-Type: application/json' \
+     --data '
+{
+     "query": "SELECT * FROM example_db.demo_data.home_rentals;",
+     "response_format": "jsonlines"
+}
+'
+```
 
 ```python Python
 import requests
@@ -70,8 +116,8 @@ resp = requests.post(url, json={'query':
 
 <ResponseExample>
 
-```json Response
- {
+```json Response (Default)
+{
     "column_names": [
         "sqft",
         "rental_price"
@@ -90,7 +136,22 @@ resp = requests.post(url, json={'query':
         ]
     ],
     "type": "table"
-    }
+}
+```
+
+```text Response (SSE format)
+data: {"type": "table", "column_names": ["sqft", "rental_price"], "context": {"db": "mindsdb"}}
+
+data: [[917, 3901], [194, 2042]]
+
+data: [[543, 1871], [289, 1563]]
+
+```
+
+```text Response (JSON Lines format)
+{"type": "table", "column_names": ["sqft", "rental_price"], "context": {"db": "mindsdb"}}
+[[917, 3901], [194, 2042]]
+[[543, 1871], [289, 1563]]
 ```
 
 </ResponseExample>
diff --git a/docs/sdks/python/agents.mdx b/docs/sdks/python/agents.mdx
index f5cf58e11ce..b6c170b90fc 100644
--- a/docs/sdks/python/agents.mdx
+++ b/docs/sdks/python/agents.mdx
@@ -307,6 +307,12 @@ This parameter defines the time the agent can take to come back with an answer.
 
 For example, when the `timeout` parameter is set to 10, the agent has 10 seconds to return an answer. If the agent takes longer than 10 seconds, it aborts the process and comes back with an answer indicating its failure to return an answer within the defined time interval.
 
+### `mode`
+
+This parameter defines the agent's response style, allowing users to partially control the output format. Supported values include `text` and `sql`.
+
+When set, the agent will tailor its responses to match the specified format. Note that the agent may still adapt its output when necessary to ensure clarity or correctness.
+
 ## Get Agents
 
 You can get an existing agent with the `get()` method.
diff --git a/docs/setup/custom-config.mdx b/docs/setup/custom-config.mdx
index 89772412af0..0a76a038edc 100644
--- a/docs/setup/custom-config.mdx
+++ b/docs/setup/custom-config.mdx
@@ -191,6 +191,38 @@ Connection parameters for the MySQL API include:
 
 </Accordion>
 
+<Accordion title="MCP API">
+
+The `mcp` section configures the [MCP server](/model-context-protocol/usage).
+
+```json
+"api": {
+    "mcp": {
+        "cors": {
+            "enabled": true,
+            "allow_origins": [],
+            "allow_origin_regex": "https?://(localhost|127\\.0\\.0\\.1)(:\\d+)?",
+            "allow_headers": ["*"]
+        },
+        "rate_limit": {
+            "enabled": false,
+            "requests_per_minute": 60
+        },
+        "dns_rebinding_protection": false
+    }
+}
+```
+
+* `cors.enabled`: Enables CORS headers on MCP endpoints. Can also be set via `MINDSDB_MCP_CORS_ENABLED`.
+* `cors.allow_origins`: List of allowed origins. Can also be set via `MINDSDB_MCP_ALLOW_ORIGINS` (comma-separated).
+* `cors.allow_origin_regex`: Regex pattern for allowed origins. Can also be set via `MINDSDB_MCP_ALLOW_ORIGIN_REGEXP`.
+* `cors.allow_headers`: List of allowed request headers. Can also be set via `MINDSDB_MCP_ALLOW_HEADERS` (comma-separated).
+* `rate_limit.enabled`: Enables per-IP rate limiting. Can also be set via `MINDSDB_MCP_RATE_LIMIT_ENABLED`.
+* `rate_limit.requests_per_minute`: Maximum number of requests per minute per IP. Can also be set via `MINDSDB_MCP_RATE_LIMIT_RPM`.
+* `dns_rebinding_protection`: When `true`, the MCP transport validates the `Host` header against a list of known-safe hosts to prevent DNS rebinding attacks. Disabled by default (`false`). Enable it when running MindsDB locally and you want to restrict MCP access to `localhost` only. Can also be set via `MINDSDB_MCP_DNS_REBINDING_PROTECTION`.
+
+</Accordion>
+
 </AccordionGroup>
 
 #### `cache`
diff --git a/docs/sitemaps/use_cases.mdx b/docs/sitemaps/use_cases.mdx
index c1c0baa3637..771cca4429f 100644
--- a/docs/sitemaps/use_cases.mdx
+++ b/docs/sitemaps/use_cases.mdx
@@ -37,7 +37,6 @@ https://docs.mindsdb.com/use-cases/data_enrichment/hugging-face-inference-api-ex
 Predictive Analytics:
 https://docs.mindsdb.com/use-cases/predictive_analytics/overview
 https://docs.mindsdb.com/use-cases/predictive_analytics/house-sales-forecasting
-https://docs.mindsdb.com/use-cases/predictive_analytics/expenditures-statsforecast
 https://docs.mindsdb.com/use-cases/predictive_analytics/eeg-forecasting
 
 In-Database Machine Learning:
diff --git a/docs/use-cases/in-database_ml/mindsdb-superset-snowflake.mdx b/docs/use-cases/in-database_ml/mindsdb-superset-snowflake.mdx
deleted file mode 100644
index 08461e8a42b..00000000000
--- a/docs/use-cases/in-database_ml/mindsdb-superset-snowflake.mdx
+++ /dev/null
@@ -1,188 +0,0 @@
-# Using MindsDB Machine Learning to Solve a Real-World **time series** Problem
-
-Let’s use these powerful AI tables in a real-world scenario. (if you are not familiar with AI-Tables, you can learn about them in [here](/sql/tutorials/ai-tables/). 
-
-Imagine that you are a data analyst at the Chicago Transit Authority. Every day, you need to optimize the number of buses per route to avoid overcrowded or empty buses. You need machine learning to forecast the number of rides per bus, per route, and by time of day. The data you have looks like the table below with route_id, timestamp, number of rides, and day-type (W = weekend)
-
-![Income vs Debt model](/assets/sql/tutorials/snowflake-superset/8-multivariate_problem.jpg)
-
-This is a difficult machine learning problem that is common in databases. A timestamp indicates that we are dealing with the time-series problem. The data is further complicated by the type of day (day-type) the row contains and this is called multivariate. Additionally, there is high-cardinality as each route will have multiple row entries each with different timestamps, rides, and day types.
-
-Let’s see how we can use machine learning with MindsDB to optimize the number of buses per route and visualize the results.
-
-## Set Up MindsDB
-
-First things first! You need to connect your database to MindsDB. One of the easy ways to do so is to create a [MindsDB cloud](/setup/cloud/) account. If you prefer to deploy MindsDB locally, please refer to installation instructions via [Docker](/setup/self-hosted/docker/) or [PyPI](/setup/self-hosted/pip/windows/).
-
-Once an account is created you can connect to Snowflake using standard parameters like database name (in this case the Chicago Transit Authority), host, port, username, password, etc.
-
-![mindsdb connect](/assets/sql/tutorials/snowflake-superset/9-connect_to_MindsDB.png)
-
-
-## Connect MindsDB to the Data for model training
-
-MindsDB works through a MySQL Wire protocol. Therefore, you can connect to it using any MySQL client. Here, we’ll use the DBeaver database client and can see the Snowflake databases we are connected to.
-
-![Dbeaver connect](/assets/sql/tutorials/snowflake-superset/10-DBeaver connection.png)
-
-### Step 1: Getting the Training Data
-
-We start by getting the training data from the database that we connected to our MindsDB cloud account. It is always good to first make sure that all the databases are present and the connections correct.
-
-
-```sql
-show databases;
-```
-
-![show dbs](/assets/sql/tutorials/snowflake-superset/12-show_dtabases.png)
-
-MindsDB comes with some built-in databases as follows:
-
-* INFORMATION_SCHEMA stores information about MindsDB,
-* MINDSDB stores metadata about the predictors and allows access to the created predictors as tables,
-* DATASOURCE for connecting to data or uploading files.
-
-The SNF database is the database of the Chicago Transit Authority that we connected. It provides us with the training data. Let’s check it.
-
-```sql
-SELECT *
-FROM CHICAGO_TRANSIT_AUTHORITY.PUBLIC.CTA_BUS_RIDES_LATEST
-LIMIT 100;
-```
-
-![show dbs](/assets/sql/tutorials/snowflake-superset/13-info_schema.png)
-
-The training data consists of the number of rides per bus route and day. For example, on 2001-07-03, there were 7354 rides on bus route 3.
-
-You can download the dataset [here](https://github.com/mindsdb/benchmarks/blob/main/benchmarks/datasets/chicago_transit_ts/CTA_2019_2020.csv) and execute the SQL commands along with the tutorial!
-
-### Step 2: Training the Predictive Model
-
-Let’s move on to the next step, which is training the predictive model. For that, we’ll use the MINDSDB database.
-
-```sql
-use mindsdb;
-show tables
-```
-![show dbs](/assets/sql/tutorials/snowflake-superset/14-table.png)
-
-MINDSDB database comes with the predictors and commands tables. The predictors table lets us see the status of our predictive models. For example, assuming that we have already trained our predictive model for forecasting the number of rides, we’ll see the following.
-
-```sql
-SELECT name, status FROM MINDSDB.PREDICTORS;
-```
-
-![show status](/assets/sql/tutorials/snowflake-superset/15-query.png)
-
-The process of training a predictive model using MindsDB is as simple as creating a view or a table.
-
-```sql
-CREATE MODEL mindsdb.rides_forecaster_demo FROM snf (
-SELECT ROUTE, RIDES, DATE
-FROM CHICAGO_TRANSIT_AUTHORITY.PUBLIC.CTA_BUS_RIDES_LATEST WHERE DATE > '2020-01-01') 
-PREDICT RIDES ORDER BY DATE GROUP BY ROUTE
-WINDOW 10 HORIZON 7;
-```
-
-Let’s discuss the statement above. We create a predictor table using the `CREATE MODEL` statement and specifying the database from which the training data comes. The code in `yellow` selects the filtered training data. After that, we use the `PREDICT` keyword to define the column whose data we want to forecast.
-Next, there are standard SQL clauses, such as `ORDER BY, GROUP BY, WINDOW, and HORIZON`. We use the `ORDER BY` clause and the DATE column as its argument. By doing so, we emphasize that we deal with a time-series problem. We order the rows by date. The `GROUP BY` clause divides the data into partitions. Here, each of them relates to a particular bus route. We take into account just the last ten rows for every given prediction. Hence, we use `WINDOW` 10. To prepare the forecast of the number of bus rides for the next week, we define `HORIZON` 7.
-Now, you can execute the CREATE MODEL statement and wait until your predictive model is complete. The MINDSDB.PREDICTORS table stores its name as rides_forecaster_demo and its status as training. Once your predictive model is ready, the status changes to complete.
-
-## Step 3: Getting the Forecasts
-
-We are ready to go to the last step, i.e., using the predictive model to get future data. One way is to query the rides_forecaster_demo predictive model directly. Another way is to join this predictive model table to the table with historical data before querying it.
-
-We consider a time-series problem. Therefore, it is better to join our predictive model table to the table with historical data.
-
-```sql
-SELECT tb.ROUTE, tb.RIDES AS PREDICTED_RIDES
-FROM snf.PUBLIC.CTA_BUS_RIDES_LATEST AS ta
-JOIN mindsdb.rides_forecaster_demo AS tb 
-WHERE ta.ROUTE = "171" AND ta.DATE > LATEST
-LIMIT 7;
-```
-
-Let’s analyze it. We join the table that stores historical data (i.e., snf.PUBLIC.CTA_BUS_RIDES_LATEST) to our predictive model table (i.e., mindsdb.rides_forecaster_demo). The queried information is the route and the predicted number of rides per route. And the usage of the condition ta.DATE > LATEST (provided by MindsDB) ensures that we get the future number of rides per route.
-Let’s run the query above to forecast the number of rides for route 171 in the next seven days.
-
-![Predictive query](/assets/sql/tutorials/snowflake-superset/16-predictive_query.png)
-
-Now we know the number of rides for route 171 in the next seven days. We could do it in the same way for all the other routes.
-
-Thanks to the special SQL syntax that includes CREATE MODEL, PREDICT, and > LATEST, MindsDB makes it straightforward to run predictors on our chosen data.
-Now, let’s visualize our predictions.
-
-## Visualizing the Results using Apache Superset
-
-Apache Superset is a modern, open-source data exploration and visualization platform designed for all data personas in an organization. Superset ships with a powerful SQL editor and a no-code chart builder experience. Superset ships with support for most SQL databases out of the box and over 50 visualization types.
-
-You can connect to the Snowflake database or your MindsDB database that has a Snowflake connection within. Upon starting up your Superset workspace, your earlier defined database connection is ready to use! So you have access to the Chicago Transit Authority data, as well as to the predictions made by MindsDB.
-
-
-### Visualizing Data
-
-The two data sets that we are relevant for visualization are the stops_by_route and forecasts data sets. The stops_by_route data set contains the exact location of each bus stop for each bus route. And the forecasts data set stores the actual and predicted number of rides, confidence interval, and lower and upper bounds of prediction, per route and timestamp.
-
-Superset lets us visualize the stops_by_route data set as follows.
-
-![Visualize query](/assets/sql/tutorials/snowflake-superset/17-stops_by_route_Superset.jpg)
-
-Every bus route has a different color. Also, there is volatility associated with each bus route. Let’s publish this chart to a new dashboard by clicking the **+Save** button, then switch to the **Save as** tab, and then type in “Routes Dashboard” in the **Add to Dashboard** field.
-
-Now, let’s craft a time-series line chart to visualize actual vs predicted riders. Let’s look at the chart that presents the actual number of bus riders (in blue) and the predicted number of bus rides (in purple).
-
-![Predictive query](/assets/sql/tutorials/snowflake-superset/18-timeseries_chart.jpg)
-
-Predictions made by MindsDB closely resemble the actual data, except for a short time during March 2020 when the large-scale lockdowns took place. There we see a sudden drop in the number of bus rides. But MindsDB took some time to cope with this new reality and adjust its predictions.
-
-Lastly, let’s add a data zoom to this chart for end-users to zoom in on specific date ranges. Click the **Customize** tab and then click **Data Zoom** to enable it. Then, click the **+ Save** button and publish to the same “Routes Dashboard”.
-
-Let’s head over to the dashboard now and customize it to make it more dynamic and explorable. Click **Dashboards** in the top nav bar and then select “Routes Dashboard” from the list of dashboards. You can rearrange the chart positions by clicking the pencil icon, dragging the corners of the chart objects, and then clicking **Save**.
-
-![Timeseries chart](/assets/sql/tutorials/snowflake-superset/19-timeseries2.jpg)
-
-Let’s add some dashboard filters to this dashboard so dashboard consumers can filter the charts down to specific bus routes and volatility values. Click the right arrow (->) to pop open the filter tray. Then select the pencil icon to start editing this dashboard’s filters. Create the following filters with appropriate filter names:
-
-* A **Value** filter on the **route** column from the **forecasts** table.
-* A **Numerical range** filter on the **volatility** column from the **stops_by_route** table.
-
-Click Save to publish these filters.
-
-![Filters](/assets/sql/tutorials/snowflake-superset/20-filters1.jpg)
-
-![Filters](/assets/sql/tutorials/snowflake-superset/20-filters2.jpg)
-
-Let’s give these filters for a test ride! Use the routes filter to only show information for routes 1, 100, and 1001.
-
-![Timeseries chart](/assets/sql/tutorials/snowflake-superset/21-graph.jpg)
-
-We could zoom in to see the time during the first large-scale lockdowns in March 2020. For these particular routes, the predictions made by MindsDB are not so far off.
-
-![Timeseries chart](/assets/sql/tutorials/snowflake-superset/22-graph.jpg)
-
-Now, let’s use our volatility filter to view only the routes with volatility values greater than 55.
-
-![Timeseries chart](/assets/sql/tutorials/snowflake-superset/23-graph.jpg)
-
-
-## Conclusions: Powerful forecasting with MindsDB, your database, and Superset
-
-The combination of MindsDB and your database covers all the phases of the ML lifecycle. And Superset helps you to visualize the data in any form of diagrams, charts, or dashboards.
-
-
-![Timeseries chart](/assets/sql/tutorials/snowflake-superset/24-MindsDB_ML-Workflow.png)
-
-
-MindsDB provides easy-to-use predictive models through AI Tables. You can create these predictive models using SQL statements and feeding the input data. Also, you can query them the same way you query a table. The easiest way to get started with Superset is with the free tier for [Preset Cloud](https://preset.io/product/), a hassle-free and fully hosted cloud service for Superset.
-
-We encourage you to try some predictions with your own data, so please sign up for a [free MindsDB cloud account](https://cloud.mindsdb.com/signup) and if you need any help with MindsDB, feel free to ask our [Slack](https://mindsdb.com/joincommunity) and [Github](https://github.com/mindsdb/mindsdb/discussions) communities.
-
-## What's Next?
-
-Have fun while trying it out yourself!
-
-* Bookmark [MindsDB repository on GitHub](https://github.com/mindsdb/mindsdb).
-* Sign up for a free [MindsDB account](https://cloud.mindsdb.com/register).
-* Engage with the MindsDB community on [Slack](https://mindsdb.com/joincommunity) or [GitHub](https://github.com/mindsdb/mindsdb/discussions) to ask questions and share your ideas and thoughts.
-
-If this tutorial was helpful, please give us a GitHub star [here](https://github.com/mindsdb/mindsdb).
diff --git a/docs/use-cases/predictive_analytics/expenditures-statsforecast.mdx b/docs/use-cases/predictive_analytics/expenditures-statsforecast.mdx
deleted file mode 100644
index 26942cfc11e..00000000000
--- a/docs/use-cases/predictive_analytics/expenditures-statsforecast.mdx
+++ /dev/null
@@ -1,83 +0,0 @@
----
-title: Forecast Monthly Expenditures with Nixtla's StatsForecast and MindsDB
-sidebarTitle: Forecast Monthly Expenditures
----
-
-In this tutorial, we'll create a model to forecast expenditures based on historical data using the Nixtla's StatsForecast engine.
-
-## Connect a database
-
-We use a table from our MySQL public demo database, so let’s start by connecting it to MindsDB.
-
-```sql
-CREATE DATABASE mysql_historical
-WITH ENGINE = 'mysql',
-PARAMETERS = {
-    "user": "user",
-    "password": "MindsDBUser123!",
-    "host": "samples.mindsdb.com",
-    "port": "3306",
-    "database": "public"
-};
-```
-
-Now that we’ve connected our database to MindsDB, let’s query the data to be used in the example:
-
-```sql
-SELECT *
-FROM mysql_historical.historical_expenditures
-LIMIT 3;
-```
-
-## Deploy a time-series model
-
-Please note that before using the StatsForecast engine, you should create it with the below command:
-
-```sql
-CREATE ML_ENGINE statsforecast
-FROM statsforecast;
-```
-
-You can check the available engines with this command:
-
-```sql
-SHOW ML_ENGINES;
-```
-
-Let’s create a model table to forecast the expenditures:
-
-```sql
-CREATE MODEL quarterly_expenditure_forecaster
-FROM mysql_historical
-  (SELECT * FROM historical_expenditures)
-PREDICT expenditure
-ORDER BY month
-GROUP BY category
-WINDOW 12
-HORIZON 3
-USING ENGINE = 'statsforecast';
-```
-
-We can check the training status with the following query:
-
-```sql
-DESCRIBE quarterly_expenditure_forecaster;
-```
-
-## Make predictions
-
-Once the model status is complete, the behavior is the same as with any other AI table – you can query for batch predictions by joining it with a data table.
-
-```sql
-SELECT m.month as month, m.expenditure as forecasted
-FROM mindsdb.quarterly_expenditure_forecaster as m
-JOIN mysql_historical.historical_expenditures as t
-WHERE t.month > LATEST
-AND t.category = 'food';
-```
-
-The `historical_expenditures` table is used to make batch predictions. Upon joining the `quarterly_expenditure_forecaster` model with the `historical_expenditures` table, we get predictions for the next quarter as defined by the `HORIZON 3` clause.
-
-MindsDB provides the `LATEST` keyword that marks the latest training data point. In the `WHERE` clause, we specify the `month > LATEST` condition to ensure the predictions are made for data after the latest training data point.
-
-If we train the model using data from January 2020 until December 2020 (as defined by `WINDOW 12`), then the predictions come for the first quarter of 2021 (as defined by `HORIZON 3`).
diff --git a/docs/use-cases/predictive_analytics/house-sales-statsforecast.mdx b/docs/use-cases/predictive_analytics/house-sales-statsforecast.mdx
deleted file mode 100644
index dd9c625817a..00000000000
--- a/docs/use-cases/predictive_analytics/house-sales-statsforecast.mdx
+++ /dev/null
@@ -1,137 +0,0 @@
----
-title: Forecasting Quarterly House Sales with StatsForecast
-sidebarTitle: House Sales with StatsForecast
----
-
-## Introduction
-
-In this tutorial, we introduce Nixtla’s StatsForecast integration which offers numerous univariate time series forecasting models optimized for high performance and scalability. We’ll go through an example to predict the real estate sales.
-
-## Prerequisites
-
-### MindsDB Setup
-
-Install MindsDB locally via [Docker](/setup/self-hosted/docker) or [Docker Desktop](/setup/self-hosted/docker-desktop).
-
-### Creating an ML Engine
-
-Please note that before using the StatsForecast engine, you should create it with the below command:
-
-```sql
-CREATE ML_ENGINE statsforecast
-FROM statsforecast;
-```
-
-You can check the available engines with this command:
-
-```sql
-SHOW ML_ENGINES;
-```
-
-If you see the StatsForecast engine on the list, you are ready to follow the tutorials.
-
-## Tutorial
-
-### Connecting the Data
-
-In this tutorial, we take our [House Sales tutorial](/sql/tutorials/house-sales-forecasting) and redo it using the StatsForecast engine.
-
-We use a table from our MySQL public demo database, so let’s start by connecting MindsDB to it:
-
-```sql
-CREATE DATABASE mysql_demo_db
-WITH ENGINE = 'mysql',
-PARAMETERS = {
-    "user": "user",
-    "password": "MindsDBUser123!",
-    "host": "samples.mindsdb.com",
-    "port": "3306",
-    "database": "public"
-};
-```
-
-Now that we’ve connected our database to MindsDB, let’s query the data to be used in the example:
-
-```sql
-SELECT *
-FROM mysql_demo_db.house_sales
-LIMIT 3;
-```
-
-Here is the output:
-
-```sql
-+----------+--------------------------+-----+--------+
-|saledate  |house_price_moving_average|type |bedrooms|
-+----------+--------------------------+-----+--------+
-|30/09/2007|441854                    |house|2       |
-|31/12/2007|441854                    |house|2       |
-|31/03/2008|441854                    |house|2       |
-+----------+--------------------------+-----+--------+
-```
-
-The `house_sales` table stores quarterly house price moving averages per property.
-
-### Creating a Model
-
-Let's create a model table to predict the house price moving average values:
-
-```sql
-CREATE MODEL mindsdb.house_sales_predictor
-FROM mysql_demo_db
-  (SELECT * FROM house_sales)
-PREDICT house_price_moving_average
-ORDER BY saledate
-GROUP BY bedrooms, type
-WINDOW 8
-HORIZON 4
-USING ENGINE = 'statsforecast';
-```
-
-The sytax is the same as in original tutorial. But here, we add the `USING` clause that specifies the ML engine used to make predictions.
-
-We can check the training status with the following query:
-
-```sql
-DESCRIBE house_sales_predictor;
-```
-
-### Making Predictions
-
-Once the model status is `complete`, the behavior is the same as with any other AI table – you can query for batch predictions by joining it with a data table:
-
-```sql
-SELECT m.saledate AS date, m.house_price_moving_average AS forecast
-FROM mindsdb.house_sales_predictor AS m
-JOIN mysql_demo_db.house_sales AS t
-WHERE t.saledate > LATEST
-AND t.type = 'house'
-AND t.bedrooms = 2
-LIMIT 3;
-```
-
-Here is the output data:
-
-```sql
-+----------------------------+----------+
-| date                       | forecast |
-+----------------------------+----------+
-| 2019-12-31 00:00:00.000000 | 510712   |
-| 2020-03-31 00:00:00.000000 | 510712   |
-| 2020-06-30 00:00:00.000000 | 510712   |
-+----------------------------+----------+
-```
-
-## What's Next?
-
-Have fun while trying it out yourself!
-
-- Bookmark [MindsDB repository on GitHub](https://github.com/mindsdb/mindsdb).
-- Install MindsDB locally via [Docker](/setup/self-hosted/docker) or [Docker Desktop](/setup/self-hosted/docker-desktop).
-- Engage with the MindsDB community on
-  [Slack](https://mindsdb.com/joincommunity) or
-  [GitHub](https://github.com/mindsdb/mindsdb/discussions) to ask questions and
-  share your ideas and thoughts.
-
-If this tutorial was helpful, please give us a GitHub star
-[here](https://github.com/mindsdb/mindsdb).
diff --git a/docs/use-cases/predictive_analytics/house-sales-timegpt.mdx b/docs/use-cases/predictive_analytics/house-sales-timegpt.mdx
deleted file mode 100644
index d0bb29e6d55..00000000000
--- a/docs/use-cases/predictive_analytics/house-sales-timegpt.mdx
+++ /dev/null
@@ -1,134 +0,0 @@
----
-title: Forecasting Quarterly House Sales with TimeGPT
-sidebarTitle: House Sales with TimeGPT
----
-
-## Introduction
-
-In this tutorial, we introduce Nixtla’s TimeGPT integration which offers the first foundational model for time series forecasting. We’ll go through an example to predict the real estate sales.
-
-## Prerequisites
-
-### MindsDB Setup
-
-Install MindsDB locally via [Docker](/setup/self-hosted/docker) or [Docker Desktop](/setup/self-hosted/docker-desktop).
-
-### Creating an ML Engine
-
-You can check the available engines with this command:
-
-```sql
-SHOW ML_ENGINES;
-```
-
-If you see the TimeGPT engine on the list, you are ready to follow the tutorials. If you do not see TimeGPT on the list, you will have to create an instance of the engine first with this command:
-
-```sql
-CREATE ML_ENGINE timegpt FROM timegpt USING timegpt_api_key = '...'
-```
-
-Notice that the `USING` clause is optional, but you must pass an API key eventually (either at model creation, engine creation, model usage, or in the mindsdb configuration file).
-
-## Tutorial
-
-### Connecting the Data
-
-In this tutorial, we take our [House Sales tutorial](/sql/tutorials/house-sales-forecasting) and redo it using the StatsForecast engine.
-
-We use a table from our MySQL public demo database, so let’s start by connecting MindsDB to it:
-
-```sql
-CREATE DATABASE mysql_demo_db_houses
-WITH ENGINE = 'mysql',
-PARAMETERS = {
-    "user": "user",
-    "password": "MindsDBUser123!",
-    "host": "samples.mindsdb.com",
-    "port": "3306",
-    "database": "public"
-};
-```
-
-Now that we’ve connected our database to MindsDB, let’s query the data to be used in the example:
-
-```sql
-SELECT *
-FROM mysql_demo_db.house_sales
-LIMIT 3;
-```
-
-Here is the output:
-
-```sql
-+----------+--------------------------+-----+--------+
-|saledate  |house_price_moving_average|type |bedrooms|
-+----------+--------------------------+-----+--------+
-|30/09/2007|441854                    |house|2       |
-|31/12/2007|441854                    |house|2       |
-|31/03/2008|441854                    |house|2       |
-+----------+--------------------------+-----+--------+
-```
-
-The `house_sales` table stores quarterly house price moving averages per property.
-
-### Creating a Model
-
-Let's create a model table to predict the house price moving average values:
-
-```sql
-CREATE MODEL nixtla_timegpt_house_sales_predictor
-FROM mysql_demo_db
-  (SELECT * FROM house_sales)
-PREDICT house_price_moving_average
-ORDER BY saledate
-GROUP BY bedrooms, type
-WINDOW 8
-HORIZON 4
-USING ENGINE = 'timegpt';
-```
-
-The syntax is the same as in the [original tutorial](/sql/tutorials/house-sales-forecasting). But here, we add the `USING` clause that specifies the ML engine used to make predictions.
-
-We can check the training status with the following query:
-
-```sql
-DESCRIBE nixtla_timegpt_house_sales_predictor;
-```
-
-### Making Predictions
-
-Once the model status is `complete`, the behavior is the same as with any other AI table – you can query for batch predictions by joining it with a data table:
-
-```sql
-
-SELECT m.saledate AS date, m.house_price_moving_average AS forecast
-FROM nixtla_timegpt_house_sales_predictor AS m
-JOIN mysql_demo_db.house_sales AS t
-LIMIT 3;
-```
-
-Here is the output data:
-
-```sql
-+----------------------------+----------+
-| date                       | forecast |
-+----------------------------+----------+
-| 2019-09-30 00:01:00.000000 | 335449.03125   |
-| 2019-09-30 00:02:00.000000 | 335449.03125   |
-| 2019-09-30 00:03:00.000000 | 335449.03125   |
-+----------------------------+----------+
-```
-
-## What's Next?
-
-Have fun while trying it out yourself!
-
-- Bookmark [MindsDB repository on GitHub](https://github.com/mindsdb/mindsdb).
-- Install MindsDB locally via [Docker](/setup/self-hosted/docker) or [Docker Desktop](/setup/self-hosted/docker-desktop).
-- Engage with the MindsDB community on
-  [Slack](https://mindsdb.com/joincommunity) or
-  [GitHub](https://github.com/mindsdb/mindsdb/discussions) to ask questions and
-  share your ideas and thoughts.
-
-If this tutorial was helpful, please give us a GitHub star
-[here](https://github.com/mindsdb/mindsdb).
diff --git a/docs/use-cases/predictive_analytics/monthly-expediture-timegpt.mdx b/docs/use-cases/predictive_analytics/monthly-expediture-timegpt.mdx
deleted file mode 100644
index 40ca8e6ed46..00000000000
--- a/docs/use-cases/predictive_analytics/monthly-expediture-timegpt.mdx
+++ /dev/null
@@ -1,128 +0,0 @@
----
-title: Forecasting Monthly Expenditures with TimeGPT
-sidebarTitle: House Sales with TimeGPT
----
-
-## Introduction
-
-In this tutorial, we introduce Nixtla’s TimeGPT integration which offers the first foundational model for time series forecasting. Follow along to see how it works.
-
-## Prerequisites
-
-### MindsDB Setup
-
-Install MindsDB locally via [Docker](/setup/self-hosted/docker) or [Docker Desktop](/setup/self-hosted/docker-desktop).
-
-### Creating an ML Engine
-
-You can check the available engines with this command:
-
-```sql
-SHOW ML_ENGINES;
-```
-
-If you see the TimeGPT engine on the list, you are ready to follow the tutorials. If you do not see TimeGPT on the list, you will have to create an instance of the engine first with this command:
-
-```sql
-CREATE ML_ENGINE timegpt FROM timegpt USING timegpt_api_key = '...'
-```
-
-Notice that the `USING` clause is optional, but you must pass an API key eventually (either at model creation, engine creation, model usage, or in the mindsdb configuration file).
-
-## Tutorial
-
-### Connecting the Data
-
-In this tutorial, we take our the Monthly Expenditures dataset.
-
-We use a table from our MySQL public demo database, so let’s start by connecting MindsDB to it:
-
-```sql
-CREATE DATABASE mysql_demo_db
-WITH ENGINE = 'mysql',
-PARAMETERS = {
-    "user": "user",
-    "password": "MindsDBUser123!",
-    "host": "samples.mindsdb.com",
-    "port": "3306",
-    "database": "public"
-};
-```
-
-Now that we’ve connected our database to MindsDB, let’s query the data to be used in the example:
-
-```sql
-SELECT *
-FROM mysql_demo_db.historical_expenditures
-LIMIT 3;
-```
-
-Here is the output:
-
-```sql
-| month | category | expenditure |
-| ----- | -------- | ----------- |
-| 1982-04-01 | food | 1162.6 |
-| 1982-05-01 | food | 1150.9 |
-| 1982-06-01 | food | 1160 |
-```
-
-### Creating a Model
-
-Let's create a model table to predict the expenditure values:
-
-```sql
-CREATE MODEL nixtla_timegpt_quarterly_expenditure_forecaster
-FROM mysql_demo_db
-  (SELECT * FROM historical_expenditures)
-PREDICT expenditure
-ORDER BY month
-GROUP BY category
-WINDOW 12
-HORIZON 3
-USING ENGINE = 'timegpt';
-```
-
-We add the `USING` clause that specifies the ML engine used to make predictions.
-
-We can check the training status with the following query:
-
-```sql
-DESCRIBE nixtla_timegpt_quarterly_expenditure_forecaster;
-```
-
-### Making Predictions
-
-Once the model status is `complete`, the behavior is the same as with any other AI table – you can query for batch predictions by joining it with a data table:
-
-```sql
-SELECT m.month as month, m.expenditure as forecasted
-FROM nixtla_timegpt_quarterly_expenditure_forecaster as m
-JOIN mysql_demo_db.historical_expenditures as t
-WHERE t.month > LATEST
-AND t.category = 'food';
-```
-
-Here is the output data:
-
-```sql
-| month | forecasted |
-| ----- | ---------- |
-| 2017-09-01 00:01:00.000000 | 10307.9423828125 |
-| 2017-09-01 00:02:00.000000 | 10307.931640625 |
-| 2017-09-01 00:03:00.000000 | 10307.9384765625 |
-```
-
-## What's Next?
-
-Have fun while trying it out yourself!
-
-- Bookmark [MindsDB repository on GitHub](https://github.com/mindsdb/mindsdb).
-- Install MindsDB locally via [Docker](/setup/self-hosted/docker) or [Docker Desktop](/setup/self-hosted/docker-desktop).
-- Engage with the MindsDB community on
-  [Slack](https://mindsdb.com/joincommunity) or
-  [GitHub](https://github.com/mindsdb/mindsdb/discussions) to ask questions and
-  share your ideas and thoughts.
-
-If this tutorial was helpful, please give us a GitHub star
-[here](https://github.com/mindsdb/mindsdb).
diff --git a/docs/use-cases/predictive_analytics/overview.mdx b/docs/use-cases/predictive_analytics/overview.mdx
index 91c0b0c9b43..7e210a07769 100644
--- a/docs/use-cases/predictive_analytics/overview.mdx
+++ b/docs/use-cases/predictive_analytics/overview.mdx
@@ -21,7 +21,6 @@ Available tutorials:
 
 <CardGroup cols={4}>
     <Card title="Forecast of Quarterly House Sales" icon="link" href="/use-cases/predictive_analytics/house-sales-forecasting"></Card>
-    <Card title="Forecast of Monthly Expenditures" icon="link" href="/use-cases/predictive_analytics/expenditures-statsforecast"></Card>
     <Card title="Forecast of Brain Activity" icon="link" href="/use-cases/predictive_analytics/eeg-forecasting"></Card>
     <Card title="Anomaly Detection" icon="link" href="/integrations/ai-engines/anomaly"></Card>
 </CardGroup>
diff --git a/mindsdb/__main__.py b/mindsdb/__main__.py
index f5d2a672e2d..3a8921e995c 100644
--- a/mindsdb/__main__.py
+++ b/mindsdb/__main__.py
@@ -34,7 +34,12 @@
 )
 from mindsdb.utilities.ps import is_pid_listen_port, get_child_pids
 import mindsdb.interfaces.storage.db as db
-from mindsdb.utilities.fs import clean_process_marks, clean_unlinked_process_marks, create_pid_file, delete_pid_file
+from mindsdb.utilities.fs import (
+    clean_process_marks,
+    clean_unlinked_process_marks,
+    create_pid_file,
+    delete_pid_file,
+)
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities.auth import register_oauth_client, get_aws_meta_data
 from mindsdb.utilities.sentry import sentry_sdk  # noqa: F401
@@ -154,12 +159,25 @@ def close_api_gracefully(trunc_processes_struct):
 
 def clean_mindsdb_tmp_dir():
     """Clean the MindsDB tmp dir at exit."""
-    temp_dir = config["paths"]["tmp"]
-    for file in temp_dir.iterdir():
-        if file.is_dir():
-            shutil.rmtree(file)
-        else:
-            file.unlink()
+    try:
+        temp_dir = config["paths"]["tmp"]
+        if not temp_dir.exists():
+            return
+
+        for file in temp_dir.iterdir():
+            try:
+                if file.is_dir():
+                    # https://docs.python.org/3/library/shutil.html#shutil.rmtree
+                    shutil.rmtree(file)
+                else:
+                    # https://docs.python.org/3/library/pathlib.html#pathlib.Path.unlink
+                    file.unlink(missing_ok=True)
+            except PermissionError as e:
+                logger.error(f"Failed to clean %s: %s{file}: {e}")
+            except FileNotFoundError:
+                logger.error(f"File not found during cleanup: {file}")
+    except Exception as e:
+        logger.error(f"Failed to clean MindsDB tmp dir: {e}")
 
 
 def set_error_model_status_by_pids(unexisting_pids: List[int]):
@@ -360,6 +378,15 @@ def start_process(trunc_process_data: TrunkProcessData) -> None:
 
         sys.exit(0)
 
+    if config.cmd_args.mcp_stdio:
+        # StreamHandler writes to stderr by default, which MCP treats as notification messages.
+        # Raise the log level to ERROR to suppress notification spam, and explicitly set the
+        # stream to stderr in case the user has overridden it in their config.
+        os.environ["MINDSDB_CONSOLE_LOG_LEVEL"] = "ERROR"
+        config["logging"]["handlers"]["console"]["level"] = "ERROR"
+        config["logging"]["handlers"]["console"]["stream"] = "ext://sys.stderr"
+        log.configure_logging()
+
     config.raise_warnings(logger=logger)
     os.environ["MINDSDB_RUNTIME"] = "1"
 
@@ -430,6 +457,12 @@ def start_process(trunc_process_data: TrunkProcessData) -> None:
 
     clean_process_marks()
 
+    if config.cmd_args.mcp_stdio:
+        from mindsdb.api.mcp.mcp_instance import mcp
+
+        mcp.run()
+        sys.exit(0)
+
     # Get config values for APIs
     http_api_config = config.get("api", {}).get("http", {})
     mysql_api_config = config.get("api", {}).get("mysql", {})
@@ -443,7 +476,8 @@ def start_process(trunc_process_data: TrunkProcessData) -> None:
             restart_on_failure=http_api_config.get("restart_on_failure", False),
             max_restart_count=http_api_config.get("max_restart_count", TrunkProcessData.max_restart_count),
             max_restart_interval_seconds=http_api_config.get(
-                "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
+                "max_restart_interval_seconds",
+                TrunkProcessData.max_restart_interval_seconds,
             ),
         ),
         TrunkProcessEnum.MYSQL: TrunkProcessData(
@@ -454,17 +488,24 @@ def start_process(trunc_process_data: TrunkProcessData) -> None:
             restart_on_failure=mysql_api_config.get("restart_on_failure", False),
             max_restart_count=mysql_api_config.get("max_restart_count", TrunkProcessData.max_restart_count),
             max_restart_interval_seconds=mysql_api_config.get(
-                "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
+                "max_restart_interval_seconds",
+                TrunkProcessData.max_restart_interval_seconds,
             ),
         ),
         TrunkProcessEnum.JOBS: TrunkProcessData(
-            name=TrunkProcessEnum.JOBS.value, entrypoint=start_scheduler, args=(config.cmd_args.verbose,)
+            name=TrunkProcessEnum.JOBS.value,
+            entrypoint=start_scheduler,
+            args=(config.cmd_args.verbose,),
         ),
         TrunkProcessEnum.TASKS: TrunkProcessData(
-            name=TrunkProcessEnum.TASKS.value, entrypoint=start_tasks, args=(config.cmd_args.verbose,)
+            name=TrunkProcessEnum.TASKS.value,
+            entrypoint=start_tasks,
+            args=(config.cmd_args.verbose,),
         ),
         TrunkProcessEnum.ML_TASK_QUEUE: TrunkProcessData(
-            name=TrunkProcessEnum.ML_TASK_QUEUE.value, entrypoint=start_ml_task_queue, args=(config.cmd_args.verbose,)
+            name=TrunkProcessEnum.ML_TASK_QUEUE.value,
+            entrypoint=start_ml_task_queue,
+            args=(config.cmd_args.verbose,),
         ),
         TrunkProcessEnum.LITELLM: TrunkProcessData(
             name=TrunkProcessEnum.LITELLM.value,
@@ -474,7 +515,8 @@ def start_process(trunc_process_data: TrunkProcessData) -> None:
             restart_on_failure=litellm_api_config.get("restart_on_failure", False),
             max_restart_count=litellm_api_config.get("max_restart_count", TrunkProcessData.max_restart_count),
             max_restart_interval_seconds=litellm_api_config.get(
-                "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
+                "max_restart_interval_seconds",
+                TrunkProcessData.max_restart_interval_seconds,
             ),
         ),
     }
@@ -554,7 +596,11 @@ async def join_process(trunc_process_data: TrunkProcessData):
                         trunc_process_data.process = None
                         if trunc_process_data.name == TrunkProcessEnum.HTTP.value:
                             # do not open GUI on HTTP API restart
-                            trunc_process_data.args = (config.cmd_args.verbose, None, True)
+                            trunc_process_data.args = (
+                                config.cmd_args.verbose,
+                                None,
+                                True,
+                            )
                         start_process(trunc_process_data)
                         api_name, port, started = await wait_api_start(
                             trunc_process_data.name,
diff --git a/mindsdb/api/a2a/README.md b/mindsdb/api/a2a/README.md
index cddb2ccf8dd..787b2d8c409 100644
--- a/mindsdb/api/a2a/README.md
+++ b/mindsdb/api/a2a/README.md
@@ -14,7 +14,7 @@ The A2A API runs as part of the MindsDB HTTP API, allowing you to:
 ## Prerequisites
 
 - MindsDB running
-- Python 3.10 or higher
+- Python 3.10.20 or higher
 
 ## Running A2A API
 
diff --git a/mindsdb/api/common/middleware.py b/mindsdb/api/common/middleware.py
index 7730b178ad4..6fb93380191 100644
--- a/mindsdb/api/common/middleware.py
+++ b/mindsdb/api/common/middleware.py
@@ -1,13 +1,15 @@
 import os
+import time
 import hmac
 import secrets
 import hashlib
+from collections import deque
 from http import HTTPStatus
 from typing import Optional
 
-from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import JSONResponse
 from starlette.requests import Request
+from starlette.types import ASGIApp, Receive, Scope, Send
 
 from mindsdb.utilities import log
 from mindsdb.utilities.config import config
@@ -24,6 +26,10 @@ def get_pat_fingerprint(token: str) -> str:
     return hmac.new(SECRET_KEY.encode(), token.encode(), hashlib.sha256).hexdigest()
 
 
+if config["auth"]["token"]:
+    TOKENS.append(get_pat_fingerprint(config["auth"]["token"]))
+
+
 def generate_pat() -> str:
     logger.debug("Generating new auth token")
     token = "pat_" + secrets.token_urlsafe(32)
@@ -56,23 +62,106 @@ def revoke_pat(raw_token: str) -> bool:
     return False
 
 
-class PATAuthMiddleware(BaseHTTPMiddleware):
-    def _extract_bearer(self, request: Request) -> Optional[str]:
-        h = request.headers.get("Authorization")
+class PATAuthMiddleware:
+    """Pure ASGI middleware (compatible with SSE / streaming responses).
+    The class is not inherited from starlette.middleware.base.BaseHTTPMiddleware
+    bacause it collect responses to buffer, which is not good for streaming
+    """
+
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    @staticmethod
+    def _extract_bearer(headers: dict) -> Optional[str]:
+        h = headers.get("authorization")
         if not h or not h.startswith("Bearer "):
             return None
         return h.split(" ", 1)[1].strip() or None
 
-    async def dispatch(self, request: Request, call_next):
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
         if config.get("auth", {}).get("http_auth_enabled", False) is False:
-            return await call_next(request)
+            await self.app(scope, receive, send)
+            return
 
-        token = self._extract_bearer(request)
-        if not token or not verify_pat(token):
-            return JSONResponse({"detail": "Unauthorized"}, status_code=HTTPStatus.UNAUTHORIZED)
+        if scope.get("method") == "OPTIONS":
+            await self.app(scope, receive, send)
+            return
 
-        request.state.user = config["auth"].get("username")
-        return await call_next(request)
+        request = Request(scope)
+        token = self._extract_bearer(dict(request.headers))
+        if not token or not verify_pat(token):
+            response = JSONResponse({"detail": "Unauthorized"}, status_code=HTTPStatus.UNAUTHORIZED)
+            await response(scope, receive, send)
+            return
+
+        scope.setdefault("state", {})["user"] = config["auth"].get("username")
+        await self.app(scope, receive, send)
+
+
+class RateLimitMiddleware:
+    """Rate limiting middleware using a sliding window counter. Tracks requests per client IP."""
+
+    def __init__(self, app: ASGIApp, requests_per_minute: int) -> None:
+        self.app = app
+        self.requests_per_minute = requests_per_minute
+        self._window = 60.0  # seconds
+        self._counters: dict[str, deque] = {}
+
+    def _get_client_key(self, scope: Scope) -> str:
+        client = scope.get("client")
+        if client:
+            return client[0]
+        return "unknown"
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        if scope.get("method") == "OPTIONS":
+            await self.app(scope, receive, send)
+            return
+
+        # Clients usually repeat this request until
+        # the connection is established, so no rate limit it.
+        if scope.get("method") == "GET" and scope.get("path", "").endswith("/sse"):
+            await self.app(scope, receive, send)
+            return
+
+        client_key = self._get_client_key(scope)
+        now = time.monotonic()
+        window_start = now - self._window
+
+        timestamps = self._counters.setdefault(client_key, deque())
+
+        # Evict timestamps outside the current window
+        while timestamps and timestamps[0] <= window_start:
+            timestamps.popleft()
+
+        if len(timestamps) >= self.requests_per_minute:
+            retry_after = int(self._window - (now - timestamps[0])) + 1
+        else:
+            retry_after = None
+            timestamps.append(now)
+
+        if retry_after is not None:
+            response = JSONResponse(
+                {"detail": f"Too Many Requests, retry after {retry_after} seconds"},
+                status_code=HTTPStatus.TOO_MANY_REQUESTS,
+                headers={"Retry-After": str(retry_after)},
+            )
+            await response(scope, receive, send)
+            return
+
+        stale_keys = [k for k, ts in self._counters.items() if not ts or ts[-1] <= window_start]
+        for k in stale_keys:
+            del self._counters[k]
+
+        await self.app(scope, receive, send)
 
 
 # Used by mysql protocol
diff --git a/mindsdb/api/executor/command_executor.py b/mindsdb/api/executor/command_executor.py
index 3cc2e5f50b5..25d8858f458 100644
--- a/mindsdb/api/executor/command_executor.py
+++ b/mindsdb/api/executor/command_executor.py
@@ -75,7 +75,8 @@
 
 import mindsdb.utilities.profiler as profiler
 
-from mindsdb.api.executor.sql_query.result_set import Column, ResultSet
+from mindsdb.api.executor.sql_query.result_set import ResultSet
+from mindsdb.utilities.types.column import Column
 from mindsdb.api.executor.sql_query import SQLQuery
 from mindsdb.api.executor.data_types.answer import ExecuteAnswer
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import (
@@ -1483,13 +1484,11 @@ def answer_drop_kb(self, statement: DropKnowledgeBase, database_name: str) -> Ex
     def answer_create_agent(self, statement, database_name):
         project_name, name = match_two_part_name(statement.name, default_db_name=database_name)
 
-        provider = statement.params.pop("provider", None)
         try:
             _ = self.session.agents_controller.add_agent(
                 name=name,
                 project_name=project_name,
-                model_name=statement.model,
-                provider=provider,
+                model=statement.model,
                 params=variables_controller.fill_parameters(statement.params),
             )
         except EntityExistsError as e:
@@ -1520,7 +1519,7 @@ def answer_update_agent(self, statement: UpdateAgent, database_name: str):
             _ = self.session.agents_controller.update_agent(
                 name,
                 project_name=project_name,
-                model_name=model,
+                model=model,
                 params=variables_controller.fill_parameters(statement.params),
             )
         except (EntityExistsError, EntityNotExistsError, ValueError) as e:
diff --git a/mindsdb/api/executor/data_types/sql_answer.py b/mindsdb/api/executor/data_types/sql_answer.py
new file mode 100644
index 00000000000..0a8b6087dbf
--- /dev/null
+++ b/mindsdb/api/executor/data_types/sql_answer.py
@@ -0,0 +1,129 @@
+from typing import Generator
+from dataclasses import dataclass
+
+import orjson
+import numpy as np
+import pandas as pd
+
+from mindsdb.utilities.json_encoder import CustomJSONEncoder
+from mindsdb.api.executor.sql_query.result_set import ResultSet
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
+
+
+@dataclass
+class SQLAnswer:
+    """Container for SQL query execution results and metadata.
+
+    Attributes:
+        resp_type: Type of response (OK, ERROR, TABLE, COLUMNS_TABLE).
+        result_set: Query result data as a ResultSet object.
+        status: Status code for the response.
+        state_track: List of state tracking information.
+        error_code: Error code if query execution failed.
+        error_message: Human-readable error message if query failed.
+        affected_rows: Number of rows affected by the query (for DML operations).
+        mysql_types: List of MySQL data types for result columns.
+    """
+
+    resp_type: RESPONSE_TYPE = RESPONSE_TYPE.OK
+    result_set: ResultSet | None = None
+    status: int | None = None
+    state_track: list[list] | None = None
+    error_code: int | None = None
+    error_message: str | None = None
+    affected_rows: int | None = None
+    mysql_types: list[MYSQL_DATA_TYPE] | None = None
+
+    @property
+    def type(self) -> RESPONSE_TYPE:
+        """Get the response type.
+
+        Returns:
+            RESPONSE_TYPE: The type of this SQL response.
+        """
+        return self.resp_type
+
+    def stream_http_response_sse(self, context: dict | None) -> Generator[str, None, None]:
+        """Stream response in Server-Sent Events (SSE) format.
+
+        Args:
+            context: Optional context information.
+
+        Yields:
+            str: SSE-formatted data lines (prefixed with "data: ").
+        """
+        for piece in self.stream_http_response_jsonlines(context=context):
+            yield f"data: {piece}\n"
+
+    def stream_http_response_jsonlines(self, context: dict | None) -> Generator[str, None, None]:
+        """Stream response as newline-delimited JSON (JSONL).
+
+        Args:
+            context: Optional context information.
+
+        Yields:
+            str: JSON-encoded lines terminated with newline characters.
+        """
+        _default_json = CustomJSONEncoder().default
+
+        if self.resp_type in (RESPONSE_TYPE.OK, RESPONSE_TYPE.ERROR):
+            response = self.dump_http_response(context=context)
+            yield orjson.dumps(response).decode() + "\n"
+            return
+
+        yield (
+            orjson.dumps(
+                {
+                    "type": RESPONSE_TYPE.TABLE,
+                    "column_names": [column.alias or column.name for column in self.result_set.columns],
+                }
+            ).decode()
+            + "\n"
+        )
+
+        for el in self.result_set.stream_data():
+            el.replace([np.nan, pd.NA, pd.NaT], None, inplace=True)
+            yield (
+                orjson.dumps(
+                    el.to_dict("split")["data"],
+                    default=_default_json,
+                    option=orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_PASSTHROUGH_DATETIME,
+                ).decode()
+                + "\n"
+            )
+
+    def dump_http_response(self, context: dict | None = None) -> dict:
+        """Serialize the complete response as a single dictionary.
+
+        Args:
+            context: Optional context information.
+
+        Returns:
+            dict: Serialized response.
+        """
+        if context is None:
+            context = {}
+        if self.resp_type == RESPONSE_TYPE.OK:
+            return {
+                "type": self.resp_type,
+                "affected_rows": self.affected_rows,
+                "context": context,
+            }
+        elif self.resp_type in (RESPONSE_TYPE.TABLE, RESPONSE_TYPE.COLUMNS_TABLE):
+            data = self.result_set.to_lists(json_types=True)
+            return {
+                "type": RESPONSE_TYPE.TABLE,
+                "data": data,
+                "column_names": [column.alias or column.name for column in self.result_set.columns],
+                "context": context,
+            }
+        elif self.resp_type == RESPONSE_TYPE.ERROR:
+            return {
+                "type": RESPONSE_TYPE.ERROR,
+                "error_code": self.error_code or 0,
+                "error_message": self.error_message,
+                "context": context,
+            }
+        else:
+            raise ValueError(f"Unsupported response type for dump HTTP response: {self.resp_type}")
diff --git a/mindsdb/api/executor/datahub/classes/response.py b/mindsdb/api/executor/datahub/classes/response.py
deleted file mode 100644
index cd0e990ed71..00000000000
--- a/mindsdb/api/executor/datahub/classes/response.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from dataclasses import dataclass, field
-from typing import List, Dict
-
-import pandas as pd
-
-from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
-
-
-@dataclass
-class DataHubResponse:
-    data_frame: pd.DataFrame = field(default_factory=pd.DataFrame)
-    columns: List[Dict] = field(default_factory=list)
-    affected_rows: int | None = None
-    mysql_types: list[MYSQL_DATA_TYPE] | None = None
diff --git a/mindsdb/api/executor/datahub/datanodes/datanode.py b/mindsdb/api/executor/datahub/datanodes/datanode.py
index 256760fc959..8be9e355949 100644
--- a/mindsdb/api/executor/datahub/datanodes/datanode.py
+++ b/mindsdb/api/executor/datahub/datanodes/datanode.py
@@ -1,10 +1,11 @@
 from pandas import DataFrame
 
-from mindsdb.api.executor.datahub.classes.response import DataHubResponse
+from mindsdb.integrations.libs.response import DataHandlerResponse
 
 
 class DataNode:
     type = "meta"
+    has_support_stream = False
 
     def __init__(self):
         pass
@@ -21,5 +22,5 @@ def get_table_columns_df(self, table_name: str, schema_name: str | None = None)
     def get_table_columns_names(self, table_name: str, schema_name: str | None = None) -> list[str]:
         pass
 
-    def query(self, query=None, session=None) -> DataHubResponse:
+    def query(self, query=None, session=None) -> DataHandlerResponse:
         pass
diff --git a/mindsdb/api/executor/datahub/datanodes/information_schema_datanode.py b/mindsdb/api/executor/datahub/datanodes/information_schema_datanode.py
index 4eabef3d7d7..ac309f72e6d 100644
--- a/mindsdb/api/executor/datahub/datanodes/information_schema_datanode.py
+++ b/mindsdb/api/executor/datahub/datanodes/information_schema_datanode.py
@@ -6,12 +6,13 @@
 from mindsdb.api.executor.datahub.datanodes.datanode import DataNode
 from mindsdb.api.executor.datahub.datanodes.integration_datanode import IntegrationDataNode
 from mindsdb.api.executor.datahub.datanodes.project_datanode import ProjectDataNode
-from mindsdb.api.executor import exceptions as exc
+from mindsdb.api.executor.datahub.classes.tables_row import TablesRow
 from mindsdb.api.executor.utilities.sql import query_df
 from mindsdb.api.executor.utilities.sql import get_query_tables
+from mindsdb.api.executor import exceptions as exc
 from mindsdb.interfaces.database.projects import ProjectController
-from mindsdb.api.executor.datahub.classes.response import DataHubResponse
-from mindsdb.integrations.libs.response import INF_SCHEMA_COLUMNS_NAMES
+from mindsdb.integrations.libs.response import TableResponse, INF_SCHEMA_COLUMNS_NAMES
+from mindsdb.utilities.types.column import Column
 from mindsdb.utilities import log
 
 from .system_tables import (
@@ -47,8 +48,6 @@
     TriggersTable,
 )
 
-from mindsdb.api.executor.datahub.classes.tables_row import TablesRow
-
 
 logger = log.getLogger(__name__)
 
@@ -206,7 +205,7 @@ def get_tables(self):
     def get_tree_tables(self):
         return {name: table for name, table in self.tables.items() if table.visible}
 
-    def query(self, query: ASTNode, session=None) -> DataHubResponse:
+    def query(self, query: ASTNode, session=None) -> TableResponse:
         query_tables = [x[1] for x in get_query_tables(query)]
 
         if len(query_tables) != 1:
@@ -225,9 +224,8 @@ def query(self, query: ASTNode, session=None) -> DataHubResponse:
             dataframe = self._get_empty_table(tbl)
         data = query_df(dataframe, query, session=self.session)
 
-        columns_info = [{"name": k, "type": v} for k, v in data.dtypes.items()]
-
-        return DataHubResponse(data_frame=data, columns=columns_info, affected_rows=0)
+        columns = [Column(name=k, dtype=v) for k, v in data.dtypes.items()]
+        return TableResponse(data=data, columns=columns, affected_rows=0)
 
     def _get_empty_table(self, table):
         columns = table.columns
diff --git a/mindsdb/api/executor/datahub/datanodes/integration_datanode.py b/mindsdb/api/executor/datahub/datanodes/integration_datanode.py
index 228bd29468c..2175db5d1a3 100644
--- a/mindsdb/api/executor/datahub/datanodes/integration_datanode.py
+++ b/mindsdb/api/executor/datahub/datanodes/integration_datanode.py
@@ -2,27 +2,24 @@
 import inspect
 import functools
 from dataclasses import astuple
-from typing import Iterable, List
 
-import numpy as np
 import pandas as pd
 from sqlalchemy.types import Integer, Float
 
 from mindsdb_sql_parser.ast.base import ASTNode
 from mindsdb_sql_parser.ast import Insert, Identifier, CreateTable, TableColumn, DropTables
 
-from mindsdb.api.executor.datahub.classes.response import DataHubResponse
 from mindsdb.api.executor.datahub.datanodes.datanode import DataNode
+from mindsdb.api.executor.datahub.datanodes.system_tables import infer_mysql_type
 from mindsdb.api.executor.datahub.classes.tables_row import TablesRow
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
 from mindsdb.api.executor.sql_query.result_set import ResultSet
-from mindsdb.integrations.libs.response import HandlerResponse, INF_SCHEMA_COLUMNS_NAMES
+from mindsdb.integrations.libs.response import INF_SCHEMA_COLUMNS_NAMES, DataHandlerResponse, ErrorResponse, OkResponse
 from mindsdb.integrations.utilities.utils import get_class_name
 from mindsdb.metrics import metrics
 from mindsdb.utilities import log
 from mindsdb.utilities.profiler import profiler
 from mindsdb.utilities.exception import QueryError
-from mindsdb.api.executor.datahub.datanodes.system_tables import infer_mysql_type
 
 logger = log.getLogger(__name__)
 
@@ -57,9 +54,9 @@ def wrapper(self, *args, **kwargs):
             query_time_with_labels = metrics.INTEGRATION_HANDLER_QUERY_TIME.labels(handler_class_name, result.type)
             query_time_with_labels.observe(elapsed_seconds)
 
-            num_rows = 0
-            if result.data_frame is not None:
-                num_rows = len(result.data_frame.index)
+            num_rows = getattr(result, "affected_rows", None)
+            if num_rows is None:
+                num_rows = -1
             response_size_with_labels = metrics.INTEGRATION_HANDLER_RESPONSE_SIZE.labels(
                 handler_class_name, result.type
             )
@@ -164,12 +161,12 @@ def create_table(
         self,
         table_name: Identifier,
         result_set: ResultSet = None,
-        columns: List[TableColumn] = None,
+        columns: list[TableColumn] = None,
         is_replace: bool = False,
         is_create: bool = False,
         raise_if_exists: bool = True,
         **kwargs,
-    ) -> DataHubResponse:
+    ) -> OkResponse:
         # is_create - create table
         #   if !raise_if_exists: error will be skipped
         # is_replace - drop table if exists
@@ -197,18 +194,18 @@ def create_table(
 
         if result_set is None:
             # it is just a 'create table'
-            return DataHubResponse()
+            return OkResponse()
 
         # native insert
         if hasattr(self.integration_handler, "insert"):
             df = result_set.to_df()
 
-            result: HandlerResponse = self.integration_handler.insert(table_name.parts[-1], df)
+            result: DataHandlerResponse = self.integration_handler.insert(table_name.parts[-1], df)
             if result is not None:
                 affected_rows = result.affected_rows
             else:
                 affected_rows = None
-            return DataHubResponse(affected_rows=affected_rows)
+            return OkResponse(affected_rows=affected_rows)
 
         insert_columns = [Identifier(parts=[x.alias]) for x in result_set.columns]
 
@@ -232,29 +229,28 @@ def create_table(
 
         if len(values) == 0:
             # not need to insert
-            return DataHubResponse()
+            return OkResponse()
 
         insert_ast = Insert(table=table_name, columns=insert_columns, values=values, is_plain=True)
 
         try:
-            result: DataHubResponse = self.query(insert_ast)
+            result: DataHandlerResponse = self.query(insert_ast)
         except Exception as e:
             msg = f"[{self.ds_type}/{self.integration_name}]: {str(e)}"
             raise DBHandlerException(msg) from e
 
-        return DataHubResponse(affected_rows=result.affected_rows)
+        return OkResponse(affected_rows=result.affected_rows)
 
     def has_support_stream(self) -> bool:
-        # checks if data handler has query_stream method
-        return hasattr(self.integration_handler, "query_stream") and callable(self.integration_handler.query_stream)
+        """Check if the integration handler supports streaming responses.
 
-    @profiler.profile()
-    def query_stream(self, query: ASTNode, fetch_size: int = None) -> Iterable:
-        # returns generator of results from handler (split by chunks)
-        return self.integration_handler.query_stream(query, fetch_size=fetch_size)
+        Returns:
+            bool: True if the integration handler supports streaming responses, False otherwise.
+        """
+        return getattr(self.integration_handler, "stream_response", False)
 
     @profiler.profile()
-    def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
+    def query(self, query: ASTNode | str = None, session=None) -> DataHandlerResponse:
         """Execute a query against the integration data source.
 
         This method processes SQL queries either as ASTNode objects or raw SQL strings
@@ -266,20 +262,20 @@ def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
             session: Session object (currently unused but kept for compatibility)
 
         Returns:
-            DataHubResponse: Response object
+            DataHandlerResponse: Response object
 
         Raises:
             NotImplementedError: If query is not ASTNode or str type
             Exception: If the query execution fails with an error response
         """
         if isinstance(query, ASTNode):
-            result: HandlerResponse = self.query_integration_handler(query=query)
+            result: DataHandlerResponse = self.query_integration_handler(query=query)
         elif isinstance(query, str):
-            result: HandlerResponse = self.native_query_integration(query=query)
+            result: DataHandlerResponse = self.native_query_integration(query=query)
         else:
             raise NotImplementedError("Thew query argument must be ASTNode or string type")
 
-        if result.type == RESPONSE_TYPE.ERROR:
+        if type(result) is ErrorResponse:
             if isinstance(query, ASTNode):
                 try:
                     query_str = query.to_string()
@@ -302,32 +298,12 @@ def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
             else:
                 raise exception from result.exception
 
-        if result.type == RESPONSE_TYPE.OK:
-            return DataHubResponse(affected_rows=result.affected_rows)
-
-        df = result.data_frame
-        # region clearing df from NaN values
-        # recursion error appears in pandas 1.5.3 https://github.com/pandas-dev/pandas/pull/45749
-        if isinstance(df, pd.Series):
-            df = df.to_frame()
-
-        columns_info = [{"name": k, "type": v} for k, v in df.dtypes.items()]
-        try:
-            # replace python's Nan, np.nan and pd.NA to None
-            # TODO keep all NAN to the end of processing, bacause replacing also changes dtypes
-            df.replace([np.nan, pd.NA, pd.NaT], None, inplace=True)
-        except Exception:
-            logger.exception("Issue with clearing DF from NaN values:")
-        # endregion
-
-        return DataHubResponse(
-            data_frame=df, columns=columns_info, affected_rows=result.affected_rows, mysql_types=result.mysql_types
-        )
+        return result
 
     @collect_metrics
-    def query_integration_handler(self, query: ASTNode) -> HandlerResponse:
+    def query_integration_handler(self, query: ASTNode) -> DataHandlerResponse:
         return self.integration_handler.query(query)
 
     @collect_metrics
-    def native_query_integration(self, query: str) -> HandlerResponse:
+    def native_query_integration(self, query: str) -> DataHandlerResponse:
         return self.integration_handler.native_query(query)
diff --git a/mindsdb/api/executor/datahub/datanodes/mindsdb_tables.py b/mindsdb/api/executor/datahub/datanodes/mindsdb_tables.py
index 8c274873465..b7fd38e3b3a 100644
--- a/mindsdb/api/executor/datahub/datanodes/mindsdb_tables.py
+++ b/mindsdb/api/executor/datahub/datanodes/mindsdb_tables.py
@@ -381,7 +381,7 @@ def get_data(cls, query: ASTNode = None, inf_schema=None, **kwargs):
 
 class AgentsTable(MdbTable):
     name = "AGENTS"
-    columns = ["NAME", "PROJECT", "MODEL_NAME", "PARAMS"]
+    columns = ["NAME", "PROJECT", "MODEL", "PARAMS"]
 
     @classmethod
     def get_data(cls, query: ASTNode = None, inf_schema=None, **kwargs):
@@ -394,15 +394,18 @@ def get_data(cls, query: ASTNode = None, inf_schema=None, **kwargs):
         project_names = {i.id: i.name for i in project_controller.get_list()}
 
         # NAME, PROJECT, MODEL, PARAMS (skills removed)
-        data = [
-            (
-                a.name,
-                project_names[a.project_id],
-                a.model_name,
-                to_json(a.params),
+        data = []
+        for a in all_agents:
+            params = a.params or {}
+            model = params.pop("model", {})
+            data.append(
+                [
+                    a.name,
+                    project_names[a.project_id],
+                    to_json(model),
+                    to_json(params),
+                ]
             )
-            for a in all_agents
-        ]
         return pd.DataFrame(data, columns=cls.columns)
 
 
diff --git a/mindsdb/api/executor/datahub/datanodes/project_datanode.py b/mindsdb/api/executor/datahub/datanodes/project_datanode.py
index 12dd98d7d23..21e07d65d83 100644
--- a/mindsdb/api/executor/datahub/datanodes/project_datanode.py
+++ b/mindsdb/api/executor/datahub/datanodes/project_datanode.py
@@ -13,12 +13,12 @@
     Delete,
 )
 
-from mindsdb.utilities.exception import EntityNotExistsError
 from mindsdb.api.executor.datahub.datanodes.datanode import DataNode
 from mindsdb.api.executor.datahub.classes.tables_row import TablesRow
-from mindsdb.api.executor.datahub.classes.response import DataHubResponse
+from mindsdb.utilities.exception import EntityNotExistsError
+from mindsdb.utilities.types.column import Column
 from mindsdb.utilities.partitioning import process_dataframe_in_partitions
-from mindsdb.integrations.libs.response import INF_SCHEMA_COLUMNS_NAMES
+from mindsdb.integrations.libs.response import INF_SCHEMA_COLUMNS_NAMES, DataHandlerResponse, OkResponse, TableResponse
 
 
 class ProjectDataNode(DataNode):
@@ -100,7 +100,7 @@ def callback(chunk):
 
         return ml_handler.predict(model_name, df, project_name=self.project.name, version=version, params=params)
 
-    def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
+    def query(self, query: ASTNode | str = None, session=None) -> DataHandlerResponse:
         if isinstance(query, str):
             query = parse_sql(query)
 
@@ -110,7 +110,7 @@ def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
             if kb_table:
                 # this is the knowledge db
                 kb_table.update_query(query)
-                return DataHubResponse()
+                return OkResponse()
 
             raise NotImplementedError(f"Can't update object: {query_table}")
 
@@ -120,7 +120,7 @@ def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
             if kb_table:
                 # this is the knowledge db
                 kb_table.delete_query(query)
-                return DataHubResponse()
+                return OkResponse()
 
             raise NotImplementedError(f"Can't delete object: {query_table}")
 
@@ -157,17 +157,15 @@ def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
                 # this is the view
                 df = self.project.query_view(query, session)
 
-                columns_info = [{"name": k, "type": v} for k, v in df.dtypes.items()]
-
-                return DataHubResponse(data_frame=df, columns=columns_info)
+                columns = [Column(name=k, dtype=v) for k, v in df.dtypes.items()]
+                return TableResponse(data=df, columns=columns)
 
             kb_table = session.kb_controller.get_table(query_table, self.project.id)
             if kb_table:
                 # this is the knowledge db
                 df = kb_table.select_query(query)
-                columns_info = [{"name": k, "type": v} for k, v in df.dtypes.items()]
-
-                return DataHubResponse(data_frame=df, columns=columns_info)
+                columns = [Column(name=k, dtype=v) for k, v in df.dtypes.items()]
+                return TableResponse(data=df, columns=columns)
 
             raise EntityNotExistsError(f"Table '{query_table}' not found in database", self.project.name)
         else:
@@ -175,7 +173,7 @@ def query(self, query: ASTNode | str = None, session=None) -> DataHubResponse:
 
     def create_table(
         self, table_name: Identifier, result_set=None, is_replace=False, params=None, is_create=None, **kwargs
-    ) -> DataHubResponse:
+    ) -> OkResponse:
         # is_create - create table
         # is_replace - drop table if exists
         # is_create==False and is_replace==False: just insert
@@ -196,6 +194,5 @@ def create_table(
 
             df = result_set.to_df()
             kb_table.insert(df, params=params)
-            return DataHubResponse()
-
+            return OkResponse()
         raise ValueError(f"Table or Knowledge Base '{table_name}' doesn't exist")
diff --git a/mindsdb/api/executor/planner/plan_join.py b/mindsdb/api/executor/planner/plan_join.py
index 603528ac6f8..a7eb26800ef 100644
--- a/mindsdb/api/executor/planner/plan_join.py
+++ b/mindsdb/api/executor/planner/plan_join.py
@@ -358,6 +358,7 @@ def _check_identifiers(node, is_table, **kwargs):
                 else:
                     self.has_ambiguous_columns = True
 
+        query.cte = None  # already used before
         query_traversal(query, _check_identifiers)
 
         self.check_query_conditions(query)
@@ -371,6 +372,8 @@ def _check_identifiers(node, is_table, **kwargs):
         # create plan
         # TODO add optimization: one integration without predictor
 
+        planned_steps_before_join = len(self.planner.plan.steps)
+
         self.step_stack = []
         for item in join_sequence:
             if isinstance(item, TableInfo):
@@ -400,20 +403,25 @@ def _check_identifiers(node, is_table, **kwargs):
         query_in.where = query.where
 
         if self.query_context["optimize_inner_join"]:
-            self.planner.plan.steps = self.optimize_inner_join(self.planner.plan.steps)
+            self.planner.plan.steps = self.optimize_inner_join(self.planner.plan.steps, planned_steps_before_join)
 
         self.close_partition()
         return self.planner.plan.steps[-1]
 
-    def optimize_inner_join(self, steps_in):
+    def optimize_inner_join(self, steps_in, min_step_num):
         steps_out = []
 
         partition_step = None
         partition_used = False
 
-        for step in steps_in:
+        for i, step in enumerate(steps_in):
             if partition_step is None:
-                if isinstance(step, FetchDataframeStep) and not partition_used and step.query.limit is not None:
+                if (
+                    i >= min_step_num
+                    and isinstance(step, FetchDataframeStep)
+                    and not partition_used
+                    and step.query.limit is not None
+                ):
                     limit = step.query.limit.value
                     step.query.limit = None
                     partition_used = True
diff --git a/mindsdb/api/executor/sql_query/result_set.py b/mindsdb/api/executor/sql_query/result_set.py
index 4d037af7bff..f3b22e13e63 100644
--- a/mindsdb/api/executor/sql_query/result_set.py
+++ b/mindsdb/api/executor/sql_query/result_set.py
@@ -1,7 +1,6 @@
 import copy
 from array import array
-from typing import Any
-from dataclasses import dataclass, field, MISSING
+from typing import Any, Generator
 
 import numpy as np
 import pandas as pd
@@ -11,8 +10,10 @@
 from mindsdb_sql_parser.ast import TableColumn
 
 from mindsdb.utilities import log
+from mindsdb.utilities.types.column import Column
 from mindsdb.api.executor.exceptions import WrongArgumentError
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
+from mindsdb.integrations.libs.response import TableResponse
 
 
 logger = log.getLogger(__name__)
@@ -57,31 +58,6 @@ def _dump_vector(value: Any) -> Any:
     return value
 
 
-@dataclass(kw_only=True, slots=True)
-class Column:
-    name: str = field(default=MISSING)
-    alias: str | None = None
-    table_name: str | None = None
-    table_alias: str | None = None
-    type: MYSQL_DATA_TYPE | None = None
-    database: str | None = None
-    flags: dict = None
-    charset: str | None = None
-
-    def __post_init__(self):
-        if self.alias is None:
-            self.alias = self.name
-        if self.table_alias is None:
-            self.table_alias = self.table_name
-
-    def get_hash_name(self, prefix):
-        table_name = self.table_name if self.table_alias is None else self.table_alias
-        name = self.name if self.alias is None else self.alias
-
-        name = f"{prefix}_{table_name}_{name}"
-        return name
-
-
 def rename_df_columns(df: pd.DataFrame, names: list | None = None) -> None:
     """Inplace rename of dataframe columns
 
@@ -104,6 +80,7 @@ def __init__(
         affected_rows: int | None = None,
         is_prediction: bool = False,
         mysql_types: list[MYSQL_DATA_TYPE] | None = None,
+        table_response: TableResponse = None,
     ):
         """
         Args:
@@ -112,9 +89,13 @@ def __init__(
             df (pd.DataFrame): injected dataframe, have to have enumerated columns and length equal to columns
             affected_rows (int): number of affected rows
         """
-        if columns is None:
-            columns = []
-        self._columns = columns
+        self._table_response: TableResponse = table_response
+        if table_response:
+            self._columns = table_response.columns
+        elif columns is None:
+            self._columns = []
+        else:
+            self._columns = columns
 
         if df is None:
             if values is None:
@@ -132,15 +113,19 @@ def __init__(
     def __repr__(self):
         col_names = ", ".join([col.name for col in self._columns])
 
+        if self._table_response is not None:
+            return f"{self.__class__.__name__}(table response, cols: {col_names})"
         return f"{self.__class__.__name__}({self.length()} rows, cols: {col_names})"
 
     def __len__(self) -> int:
+        self._load_table_response()
         if self._df is None:
             return 0
         return len(self._df)
 
     def __getitem__(self, slice_val):
         # return resultSet with sliced dataframe
+        self._load_table_response()
         df = self._df[slice_val]
         return ResultSet(columns=self.columns, df=df)
 
@@ -170,6 +155,10 @@ def from_df(
         rename_df_columns(df)
         return cls(df=df, columns=columns, is_prediction=is_prediction, mysql_types=mysql_types)
 
+    @classmethod
+    def from_table_response(cls, table_response):
+        return cls(table_response=table_response)
+
     @classmethod
     def from_df_cols(cls, df: pd.DataFrame, columns_dict: dict[str, Column], strict: bool = True) -> "ResultSet":
         """Create ResultSet from dataframe and dictionary of columns
@@ -251,6 +240,7 @@ def get_col_index(self, col):
         return col_idx
 
     def add_column(self, col, values=None):
+        self._load_table_response()
         self._columns.append(col)
 
         col_idx = len(self._columns) - 1
@@ -259,6 +249,7 @@ def add_column(self, col, values=None):
         return col_idx
 
     def del_column(self, col):
+        self._load_table_response()
         idx = self.get_col_index(col)
         self._columns.pop(idx)
 
@@ -296,27 +287,56 @@ def copy_column_to(self, col, result_set2):
         return col2
 
     def set_col_type(self, col_idx, type_name):
+        self._load_table_response()
         self.columns[col_idx].type = type_name
         if self._df is not None:
             self._df[col_idx] = self._df[col_idx].astype(type_name)
 
     # --- records ---
 
+    def _load_table_response(self):
+        """Fully load the table response by fetching all data from the table response and storing it in the _df attribute."""
+        if self._table_response is None:
+            return
+
+        self._table_response.fetchall()
+        if self._df is None:
+            self._df = self._table_response._data
+        else:
+            self._df = pd.concat([self._df, self._table_response._data])
+        self._table_response = None
+
+    def stream_data(self) -> Generator[pd.DataFrame, None, None]:
+        """Stream data from the result set.
+
+        Yields:
+            pd.DataFrame: Data frame.
+        """
+        if self._df is not None:
+            yield self._df
+        else:
+            for el in self._table_response.iterate_no_save():
+                yield el
+
     def get_raw_df(self):
+        self._load_table_response()
+        names = range(len(self._columns))
         if self._df is None:
-            names = range(len(self._columns))
             return pd.DataFrame([], columns=names)
+        self._df.columns = names
         return self._df
 
     def add_raw_df(self, df):
         if len(df.columns) != len(self._columns):
             raise WrongArgumentError(f"Record length mismatch columns length: {len(df.columns)} != {len(self.columns)}")
+        self._load_table_response()
 
         rename_df_columns(df)
 
         if self._df is None:
             self._df = df
         else:
+            rename_df_columns(self._df)
             self._df = pd.concat([self._df, df], ignore_index=True)
 
     def add_raw_values(self, values):
@@ -341,6 +361,7 @@ def get_ast_columns(self) -> list[TableColumn]:
             list[TableColumn]: A list of TableColumn objects with properly mapped SQLAlchemy types
         """
         columns: list[TableColumn] = []
+        self._load_table_response()
 
         type_mapping = {
             MYSQL_DATA_TYPE.TINYINT: sqlalchemy_types.INTEGER,
@@ -382,6 +403,7 @@ def to_lists(self, json_types=False):
             array->list, datetime64->str
         :return: list of lists
         """
+        self._load_table_response()
 
         if len(self.get_raw_df()) == 0:
             return []
@@ -408,6 +430,7 @@ def get_column_values(self, col_idx):
 
     def set_column_values(self, col_name, values):
         # values is one value or list of values
+        self._load_table_response()
         cols = self.find_columns(col_name)
         if len(cols) == 0:
             col_idx = self.add_column(Column(name=col_name))
@@ -424,7 +447,7 @@ def add_from_result_set(self, rs):
         for name in self.get_column_names():
             col_sequence.append(source_names.index(name))
 
-        raw_df = rs.get_raw_df()[col_sequence]
+        raw_df = rs.get_raw_df().iloc[:, col_sequence]
 
         self.add_raw_df(raw_df)
 
diff --git a/mindsdb/api/executor/sql_query/sql_query.py b/mindsdb/api/executor/sql_query/sql_query.py
index 7adecf15a86..0ec9e58a872 100644
--- a/mindsdb/api/executor/sql_query/sql_query.py
+++ b/mindsdb/api/executor/sql_query/sql_query.py
@@ -20,6 +20,8 @@
     ApplyTimeseriesPredictorStep,
     ApplyPredictorRowStep,
     ApplyPredictorStep,
+    InsertToTable,
+    FetchDataframeStepPartition,
 )
 
 from mindsdb.api.executor.planner.exceptions import PlanningException
@@ -33,15 +35,15 @@
     UnknownError,
     LogicError,
 )
+from mindsdb.interfaces.query_context.context_controller import query_context_controller
 import mindsdb.utilities.profiler as profiler
 from mindsdb.utilities.fs import create_process_mark, delete_process_mark
 from mindsdb.utilities.exception import EntityNotExistsError
-from mindsdb.interfaces.query_context.context_controller import query_context_controller
 from mindsdb.utilities.context import context as ctx
-
+from mindsdb.utilities.types.column import Column
 
 from . import steps
-from .result_set import ResultSet, Column
+from .result_set import ResultSet
 from .steps.base import BaseStepCall
 
 
@@ -276,6 +278,16 @@ def execute_query(self):
                 )
 
             if self.planner.plan.is_async and ctx.task_id is None:
+                # release KB locks before inserting in background
+                db_released, partition_params = self.release_kb_lock(steps)
+                if db_released:
+                    # faiss db is used as a table to insert
+                    if partition_params.get("threads", 1) > 1:
+                        raise ValueError(
+                            "It is not possible to use threads for FAISS knowledge base, "
+                            f"please remove `threads={partition_params['threads']}` parameter"
+                        )
+
                 # add to task
                 self.run_query.add_to_task()
                 # return query info
@@ -288,7 +300,7 @@ def execute_query(self):
 
             ctx.run_query_id = self.run_query.record.id
 
-        step_result = None
+        step_result: list[ResultSet] = None
         process_mark = None
         try:
             steps_classes = (x.__class__ for x in steps)
@@ -302,7 +314,7 @@ def execute_query(self):
         except Exception as e:
             if self.run_query is not None:
                 # set error and place where it stopped
-                self.run_query.on_error(e, step.step_num, self.steps_data)
+                self.run_query.on_error(e, step.step_num if "step" in locals() else -1, self.steps_data)
             raise e
         else:
             # mark running query as completed
@@ -323,10 +335,6 @@ def execute_query(self):
         self.fetched_data = step_result
 
         try:
-            if hasattr(self, "columns_list") is False:
-                # how it becomes False?
-                self.columns_list = self.fetched_data.columns
-
             if self.columns_list is None:
                 self.columns_list = self.fetched_data.columns
 
@@ -344,5 +352,21 @@ def execute_step(self, step, steps_data=None):
 
         return handler(self, steps_data=steps_data).call(step)
 
+    def release_kb_lock(self, steps):
+        # find knowledge bases that are used as tables to insert.
+        #  then release locks of vector for these knowledge bases
+        #  return partition step params and databases names that were unlocked
+        db_released, partition_params = [], {}
+        for step in steps:
+            if isinstance(step, InsertToTable):
+                db_name = self.session.kb_controller.release_lock(step.table, project_name=self.database)
+                if db_name:
+                    db_released.append(db_name)
+            if isinstance(step, FetchDataframeStepPartition):
+                dbs, _ = self.release_kb_lock(step.steps)
+                db_released.extend(dbs)
+                partition_params.update(step.params)
+        return db_released, partition_params
+
 
 SQLQuery.register_steps()
diff --git a/mindsdb/api/executor/sql_query/steps/apply_predictor_step.py b/mindsdb/api/executor/sql_query/steps/apply_predictor_step.py
index 50a0c646e41..a12e56f80fb 100644
--- a/mindsdb/api/executor/sql_query/steps/apply_predictor_step.py
+++ b/mindsdb/api/executor/sql_query/steps/apply_predictor_step.py
@@ -19,7 +19,8 @@
     ApplyPredictorStep,
 )
 
-from mindsdb.api.executor.sql_query.result_set import ResultSet, Column
+from mindsdb.api.executor.sql_query.result_set import ResultSet
+from mindsdb.utilities.types.column import Column
 from mindsdb.utilities.cache import get_cache, dataframe_checksum
 
 from .base import BaseStepCall
diff --git a/mindsdb/api/executor/sql_query/steps/fetch_dataframe.py b/mindsdb/api/executor/sql_query/steps/fetch_dataframe.py
index b81215b01cb..d73666e49e3 100644
--- a/mindsdb/api/executor/sql_query/steps/fetch_dataframe.py
+++ b/mindsdb/api/executor/sql_query/steps/fetch_dataframe.py
@@ -11,12 +11,12 @@
 )
 
 from mindsdb.api.executor.planner.steps import FetchDataframeStep
-from mindsdb.api.executor.datahub.classes.response import DataHubResponse
 from mindsdb.api.executor.sql_query.result_set import ResultSet
 from mindsdb.api.executor.planner.step_result import Result
 from mindsdb.api.executor.exceptions import UnknownError
-from mindsdb.integrations.utilities.query_traversal import query_traversal
 from mindsdb.interfaces.query_context.context_controller import query_context_controller
+from mindsdb.integrations.utilities.query_traversal import query_traversal
+from mindsdb.integrations.libs.response import TableResponse
 
 from .base import BaseStepCall
 
@@ -92,7 +92,7 @@ def call(self, step):
         if query is None:
             table_alias = (self.context.get("database"), "result", "result")
 
-            response: DataHubResponse = dn.query(step.raw_query, session=self.session)
+            response: TableResponse = dn.query(step.raw_query, session=self.session)
             df = response.data_frame
         else:
             if isinstance(step.query, (Union, Intersect)):
@@ -108,11 +108,15 @@ def call(self, step):
 
             query, context_callback = query_context_controller.handle_db_context_vars(query, dn, self.session)
 
-            response: DataHubResponse = dn.query(query=query, session=self.session)
-            df = response.data_frame
-
+            response: TableResponse = dn.query(query=query, session=self.session)
+            response.set_columns_attrs(
+                table_name=table_alias[1],
+                table_alias=table_alias[2],
+                database=table_alias[0],
+            )
             if context_callback:
-                context_callback(df, response.columns)
+                context_callback(response.data_frame, response.columns)
+            return ResultSet.from_table_response(response)
 
         # if query registered, set progress
         if self.sql_query.run_query is not None:
@@ -122,5 +126,5 @@ def call(self, step):
             table_name=table_alias[1],
             table_alias=table_alias[2],
             database=table_alias[0],
-            mysql_types=response.mysql_types,
+            mysql_types=[column.type for column in response.columns],
         )
diff --git a/mindsdb/api/executor/sql_query/steps/fetch_dataframe_partition.py b/mindsdb/api/executor/sql_query/steps/fetch_dataframe_partition.py
index 30de48b9442..9775a2867e9 100644
--- a/mindsdb/api/executor/sql_query/steps/fetch_dataframe_partition.py
+++ b/mindsdb/api/executor/sql_query/steps/fetch_dataframe_partition.py
@@ -1,3 +1,4 @@
+import time
 import copy
 import pandas as pd
 from typing import List
@@ -90,10 +91,14 @@ def call(self, step: FetchDataframeStepPartition) -> ResultSet:
                 use_threads = False
 
         on_error = step.params.get("error", "raise")
-        if use_threads:
-            return self.fetch_threads(run_query, query, thread_count=thread_count, on_error=on_error)
-        else:
-            return self.fetch_iterate(run_query, query, on_error=on_error)
+        try:
+            if use_threads:
+                return self.fetch_threads(run_query, query, thread_count=thread_count, on_error=on_error)
+            else:
+                return self.fetch_iterate(run_query, query, on_error=on_error)
+        finally:
+            # release KB locks after inserting in background
+            self.sql_query.release_kb_lock(self.substeps)
 
     def repeat_till_reach_limit(self, step, limit):
         first_table_limit = limit * 2
@@ -105,6 +110,7 @@ def repeat_till_reach_limit(self, step, limit):
         query, context_callback = query_context_controller.handle_db_context_vars(query, dn, self.session)
 
         try_num = 1
+        started_at = time.time()
         while True:
             self.substeps = copy.deepcopy(step.steps)
             query2 = copy.deepcopy(query)
@@ -126,7 +132,8 @@ def repeat_till_reach_limit(self, step, limit):
                 result = result[:limit]
                 break
 
-            if try_num > 3:
+            # break if process is too long or to many tries
+            if try_num > 3 or time.time() - started_at > 5:
                 # the last try without the limit
                 first_table_limit = None
                 continue
diff --git a/mindsdb/api/executor/sql_query/steps/insert_step.py b/mindsdb/api/executor/sql_query/steps/insert_step.py
index 2144521dca7..d7ea17cd6cb 100644
--- a/mindsdb/api/executor/sql_query/steps/insert_step.py
+++ b/mindsdb/api/executor/sql_query/steps/insert_step.py
@@ -1,7 +1,8 @@
 from mindsdb_sql_parser.ast import Identifier, Function
 
 from mindsdb.api.executor.planner.steps import SaveToTable, InsertToTable, CreateTableStep
-from mindsdb.api.executor.sql_query.result_set import ResultSet, Column
+from mindsdb.api.executor.sql_query.result_set import ResultSet
+from mindsdb.utilities.types.column import Column
 from mindsdb.utilities.exception import EntityNotExistsError
 from mindsdb.api.executor.exceptions import NotSupportedYet, LogicError
 from mindsdb.integrations.libs.response import INF_SCHEMA_COLUMNS_NAMES
diff --git a/mindsdb/api/executor/sql_query/steps/prepare_steps.py b/mindsdb/api/executor/sql_query/steps/prepare_steps.py
index b846d4f66b2..7b2950a8e5f 100644
--- a/mindsdb/api/executor/sql_query/steps/prepare_steps.py
+++ b/mindsdb/api/executor/sql_query/steps/prepare_steps.py
@@ -9,18 +9,18 @@
     GetTableColumns,
 )
 
-from mindsdb.api.executor.sql_query.result_set import ResultSet, Column
+from mindsdb.api.executor.sql_query.result_set import ResultSet
+from mindsdb.utilities.types.column import Column
 from mindsdb.utilities.config import config
 
 from .base import BaseStepCall
 
 
 class GetPredictorColumnsCall(BaseStepCall):
-
     bind = GetPredictorColumns
 
     def call(self, step):
-        mindsdb_database_name = config.get('default_project')
+        mindsdb_database_name = config.get("default_project")
 
         predictor_name = step.predictor.parts[-1]
         dn = self.session.datahub.get(mindsdb_database_name)
@@ -28,20 +28,14 @@ def call(self, step):
 
         data = ResultSet()
         for column_name in columns_names:
-            data.add_column(Column(
-                name=column_name,
-                table_name=predictor_name,
-                database=mindsdb_database_name
-            ))
+            data.add_column(Column(name=column_name, table_name=predictor_name, database=mindsdb_database_name))
         return data
 
 
 class GetTableColumnsCall(BaseStepCall):
-
     bind = GetTableColumns
 
     def call(self, step):
-
         table = step.table
         dn = self.session.datahub.get(step.namespace)
         ds_query = Select(from_table=Identifier(table), targets=[Star()], limit=Constant(0))
@@ -50,10 +44,12 @@ def call(self, step):
 
         data = ResultSet()
         for column in response.columns:
-            data.add_column(Column(
-                name=column['name'],
-                type=column.get('type'),
-                table_name=table,
-                database=self.context.get('database')
-            ))
+            data.add_column(
+                Column(
+                    name=column["name"],
+                    type=column.get("type"),
+                    table_name=table,
+                    database=self.context.get("database"),
+                )
+            )
         return data
diff --git a/mindsdb/api/executor/sql_query/steps/subselect_step.py b/mindsdb/api/executor/sql_query/steps/subselect_step.py
index 8e4e5725cf9..40e3dfbd2f2 100644
--- a/mindsdb/api/executor/sql_query/steps/subselect_step.py
+++ b/mindsdb/api/executor/sql_query/steps/subselect_step.py
@@ -15,7 +15,8 @@
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import SERVER_VARIABLES
 from mindsdb.api.executor.planner.step_result import Result
 from mindsdb.api.executor.planner.steps import SubSelectStep, QueryStep
-from mindsdb.api.executor.sql_query.result_set import ResultSet, Column
+from mindsdb.api.executor.sql_query.result_set import ResultSet
+from mindsdb.utilities.types.column import Column
 from mindsdb.api.executor.utilities.sql import query_df
 from mindsdb.api.executor.exceptions import KeyColumnDoesNotExist
 from mindsdb.integrations.utilities.query_traversal import query_traversal
@@ -183,6 +184,8 @@ def check_fields(node, is_target=None, **kwargs):
                         "version for the right syntax to use near '$$' at line 1"
                     )
 
+                key, column_quoted = (), False
+
                 match node.parts, node.is_quoted:
                     case [column_name], [column_quoted]:
                         if column_name in aliases:
diff --git a/mindsdb/api/executor/utilities/sql.py b/mindsdb/api/executor/utilities/sql.py
index 48091e5fff1..f02a9e02d67 100644
--- a/mindsdb/api/executor/utilities/sql.py
+++ b/mindsdb/api/executor/utilities/sql.py
@@ -245,12 +245,30 @@ def query_dfs(dataframes, query_ast, session=None):
     else:
         user_functions = None
 
+    # region collect table aliases. Strip schema/db prefix from column identifiers, but keep table aliases.
+    # Examples:
+    #   files.col = 1            ->  col = 1                  (schema prefix stripped)
+    #   files.a1.col = 1         ->  a1.col = 1               (schema prefix stripped, alias kept)
+    #   a1.col = a2.col          ->  a1.col = a2.col          (aliases untouched, no schema prefix)
+    #   "Custom SQL Query".col   ->  col                      (replaced subquery alias stripped)
+    known_aliases = set()
+
+    def collect_aliases(node, is_table, **kwargs):
+        if not is_table or not isinstance(node, Identifier):
+            return
+        known_aliases.add(node.parts[-1].lower())
+        if node.alias is not None:
+            known_aliases.add(node.alias.parts[-1].lower())
+
+    query_traversal(query_ast, collect_aliases)
+    # endregion
+
     def adapt_query(node, is_table, **kwargs):
         if is_table:
             return
         if isinstance(node, Identifier):
-            if len(node.parts) > 1:
-                node.parts = [node.parts[-1]]
+            if len(node.parts) > 1 and node.parts[0].lower() not in known_aliases:
+                node.parts = node.parts[1:]
                 return node
         if isinstance(node, Function):
             fnc = mysql_to_duckdb_fnc(node)
diff --git a/mindsdb/api/http/namespaces/agents.py b/mindsdb/api/http/namespaces/agents.py
index a57c4c09dc2..3a7d6612499 100644
--- a/mindsdb/api/http/namespaces/agents.py
+++ b/mindsdb/api/http/namespaces/agents.py
@@ -28,14 +28,16 @@ def create_agent(project_name, name, agent):
     if name is None:
         return http_error(HTTPStatus.BAD_REQUEST, "Missing field", 'Missing "name" field for agent')
 
-    model_name = agent.get("model_name")
-    provider = agent.get("provider")
-
     params = agent.get("params", {})
+    if agent.get("model"):
+        model = agent["model"]
+    elif "model_name" in agent:
+        model = {"model_name": agent.get("model_name"), "provider": agent.get("provider")}
+    else:
+        model = None
+
     if agent.get("data"):
         params["data"] = agent["data"]
-    if agent.get("model"):
-        params["model"] = agent["model"]
     if agent.get("prompt_template"):
         params["prompt_template"] = agent["prompt_template"]
 
@@ -54,23 +56,21 @@ def create_agent(project_name, name, agent):
         )
 
     try:
-        created_agent = agents_controller.add_agent(
-            name=name, project_name=project_name, model_name=model_name, provider=provider, params=params
-        )
+        created_agent = agents_controller.add_agent(name=name, project_name=project_name, model=model, params=params)
         return created_agent.as_dict(), HTTPStatus.CREATED
     except (ValueError, EntityExistsError):
         # Model doesn't exist.
         return http_error(
             HTTPStatus.NOT_FOUND,
             "Resource not found",
-            f'The model "{model_name}" does not exist. Please ensure that the name is correct and try again.',
+            f'The model "{model}" does not exist. Please ensure that the name is correct and try again.',
         )
     except NotImplementedError:
         # Free users trying to create agent.
         return http_error(
             HTTPStatus.UNAUTHORIZED,
             "Unavailable to free users",
-            f'The model "{model_name}" does not exist. Please ensure that the name is correct and try again.',
+            f'The model "{model}" does not exist. Please ensure that the name is correct and try again.',
         )
 
 
@@ -174,13 +174,17 @@ def put(self, project_name, agent_name):
 
         # Update
         try:
-            model_name = agent.get("model_name", None)
-            provider = agent.get("provider")
             params = agent.get("params", {})
+
+            if agent.get("model"):
+                model = agent["model"]
+            elif "model_name" in agent:
+                model = {"model_name": agent.get("model_name"), "provider": agent.get("provider")}
+            else:
+                model = None
+
             if agent.get("data"):
                 params["data"] = agent["data"]
-            if agent.get("model"):
-                params["model"] = agent["model"]
             if agent.get("prompt_template"):
                 params["prompt_template"] = agent["prompt_template"]
 
@@ -188,8 +192,7 @@ def put(self, project_name, agent_name):
                 agent_name,
                 project_name=project_name,
                 name=name,
-                model_name=model_name,
-                provider=provider,
+                model=model,
                 params=params,
             )
 
diff --git a/mindsdb/api/http/namespaces/config.py b/mindsdb/api/http/namespaces/config.py
index b31e8d9b293..da4412b7891 100644
--- a/mindsdb/api/http/namespaces/config.py
+++ b/mindsdb/api/http/namespaces/config.py
@@ -16,6 +16,10 @@
 from mindsdb.utilities.functions import decrypt, encrypt
 from mindsdb.utilities.config import Config
 from mindsdb.integrations.libs.response import HandlerStatusResponse
+from mindsdb.interfaces.knowledge_base.default_storage_resolver import (
+    get_env_available_engines,
+    resolve_default_storage_engines,
+)
 
 
 logger = log.getLogger(__name__)
@@ -34,6 +38,11 @@ def get(self):
             if value is not None:
                 resp[key] = value
 
+        knowledge_bases_config = copy.deepcopy(config["knowledge_bases"])
+        knowledge_bases_config.update(resolve_default_storage_engines(config))
+        knowledge_bases_config["engines"] = get_env_available_engines()
+        resp["knowledge_bases"] = knowledge_bases_config
+
         api_status = get_api_status()
         api_configs = copy.deepcopy(config["api"])
         for api_name, api_config in api_configs.items():
@@ -47,12 +56,18 @@ def get(self):
     def put(self):
         data = request.json
 
-        allowed_arguments = {"auth", "default_llm", "default_embedding_model", "default_reranking_model"}
+        allowed_arguments = {
+            "auth",
+            "default_llm",
+            "default_embedding_model",
+            "default_reranking_model",
+            "knowledge_bases",
+        }
         unknown_arguments = list(set(data.keys()) - allowed_arguments)
         if len(unknown_arguments) > 0:
             return http_error(HTTPStatus.BAD_REQUEST, "Wrong arguments", f"Unknown argumens: {unknown_arguments}")
 
-        nested_keys_to_validate = {"auth"}
+        nested_keys_to_validate = {"auth", "knowledge_bases"}
         for key in data.keys():
             if key in nested_keys_to_validate:
                 unknown_arguments = list(set(data[key].keys()) - set(Config()[key].keys()))
diff --git a/mindsdb/api/http/namespaces/databases.py b/mindsdb/api/http/namespaces/databases.py
index 895bc59656f..f5a75f6bc73 100644
--- a/mindsdb/api/http/namespaces/databases.py
+++ b/mindsdb/api/http/namespaces/databases.py
@@ -69,7 +69,7 @@ def post(self):
                 status = HandlerStatusResponse(success=False, error_message=str(import_error))
 
             if status.success is not True:
-                if hasattr(status, "redirect_url") and isinstance(status, str):
+                if hasattr(status, "redirect_url") and isinstance(status.redirect_url, str):
                     return {
                         "status": "redirect_required",
                         "redirect_url": status.redirect_url,
@@ -136,7 +136,7 @@ def post(self):
                 shutil.rmtree(temp_dir)
 
         if not status.success:
-            if hasattr(status, "redirect_url") and isinstance(status, str):
+            if hasattr(status, "redirect_url") and isinstance(status.redirect_url, str):
                 return {
                     "status": "redirect_required",
                     "redirect_url": status.redirect_url,
diff --git a/mindsdb/api/http/namespaces/default.py b/mindsdb/api/http/namespaces/default.py
index cdcf39d387f..4b2e0940ba5 100644
--- a/mindsdb/api/http/namespaces/default.py
+++ b/mindsdb/api/http/namespaces/default.py
@@ -65,7 +65,10 @@ def post(self):
             session.permanent = True
 
         if config["auth"]["http_auth_type"] in (HTTP_AUTH_TYPE.TOKEN, HTTP_AUTH_TYPE.SESSION_OR_TOKEN):
-            response["token"] = generate_pat()
+            if config["auth"]["token"]:
+                response["token"] = config["auth"]["token"]
+            else:
+                response["token"] = generate_pat()
 
         return response, 200
 
diff --git a/mindsdb/api/http/namespaces/file.py b/mindsdb/api/http/namespaces/file.py
index 26995a19a0a..92c551cc516 100644
--- a/mindsdb/api/http/namespaces/file.py
+++ b/mindsdb/api/http/namespaces/file.py
@@ -236,21 +236,25 @@ def on_file(file):
         file_path = os.path.join(temp_dir_path, data["file"])
         lp = file_path.lower()
         if lp.endswith((".zip", ".tar.gz")):
-            if lp.endswith(".zip"):
-                with zipfile.ZipFile(file_path) as f:
-                    f.extractall(temp_dir_path)
-            elif lp.endswith(".tar.gz"):
-                with tarfile.open(file_path) as f:
-                    safe_extract(f, temp_dir_path)
+            try:
+                if lp.endswith(".zip"):
+                    with zipfile.ZipFile(file_path) as f:
+                        safe_extract(f, temp_dir_path)
+                elif lp.endswith(".tar.gz"):
+                    with tarfile.open(file_path) as f:
+                        safe_extract(f, temp_dir_path)
+            except Exception as e:
+                shutil.rmtree(temp_dir_path, ignore_errors=True)
+                return http_error(500, "Error", str(e))
             os.remove(file_path)
             files = os.listdir(temp_dir_path)
             if len(files) != 1:
-                os.rmdir(temp_dir_path)
+                shutil.rmtree(temp_dir_path, ignore_errors=True)
                 return http_error(400, "Wrong content.", "Archive must contain only one data file.")
             file_path = os.path.join(temp_dir_path, files[0])
             mindsdb_file_name = files[0]
             if not os.path.isfile(file_path):
-                os.rmdir(temp_dir_path)
+                shutil.rmtree(temp_dir_path, ignore_errors=True)
                 return http_error(400, "Wrong content.", "Archive must contain data file in root.")
 
         try:
diff --git a/mindsdb/api/http/namespaces/knowledge_bases.py b/mindsdb/api/http/namespaces/knowledge_bases.py
index ae7a0246cc4..ccddff6ff24 100644
--- a/mindsdb/api/http/namespaces/knowledge_bases.py
+++ b/mindsdb/api/http/namespaces/knowledge_bases.py
@@ -13,7 +13,6 @@
 from mindsdb.integrations.utilities.rag.splitters.file_splitter import FileSplitter, FileSplitterConfig
 from mindsdb.interfaces.file.file_controller import FileController
 from mindsdb.interfaces.knowledge_base.preprocessing.constants import (
-    DEFAULT_CONTEXT_DOCUMENT_LIMIT,
     DEFAULT_CRAWL_DEPTH,
     DEFAULT_WEB_FILTERS,
     DEFAULT_WEB_CRAWL_LIMIT,
@@ -21,10 +20,8 @@
 from mindsdb.interfaces.knowledge_base.preprocessing.document_loader import DocumentLoader
 from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.interfaces.database.projects import ProjectController
-from mindsdb.interfaces.knowledge_base.controller import KnowledgeBaseTable
 from mindsdb.utilities import log
 from mindsdb.utilities.exception import EntityNotExistsError, EntityExistsError
-from mindsdb.integrations.utilities.rag.settings import DEFAULT_LLM_MODEL, DEFAULT_RAG_PROMPT_TEMPLATE
 
 
 logger = log.getLogger(__name__)
@@ -298,121 +295,3 @@ def delete(self, project_name: str, knowledge_base_name: str):
 
         session_controller.kb_controller.delete(knowledge_base_name, project_name)
         return "", HTTPStatus.NO_CONTENT
-
-
-def _handle_chat_completion(knowledge_base_table: KnowledgeBaseTable, request):
-    # Check for required parameters
-    query = request.json.get("query")
-
-    llm_model = request.json.get("llm_model")
-    if llm_model is None:
-        logger.warning(f'Missing parameter "llm_model" in POST body, using default llm_model {DEFAULT_LLM_MODEL}')
-
-    prompt_template = request.json.get("prompt_template")
-    if prompt_template is None:
-        logger.warning(
-            f'Missing parameter "prompt_template" in POST body, using default prompt template {DEFAULT_RAG_PROMPT_TEMPLATE}'
-        )
-
-    # Get retrieval config, if set
-    retrieval_config = request.json.get("retrieval_config", {})
-    if not retrieval_config:
-        logger.warning("No retrieval config provided, using default retrieval config")
-
-    # add llm model to retrieval config
-    if llm_model is not None:
-        retrieval_config["llm_model_name"] = llm_model
-
-    # add prompt template to retrieval config
-    if prompt_template is not None:
-        retrieval_config["rag_prompt_template"] = prompt_template
-
-    # add llm provider to retrieval config if set
-    llm_provider = request.json.get("model_provider")
-    if llm_provider is not None:
-        retrieval_config["llm_provider"] = llm_provider
-
-    # build rag pipeline
-    rag_pipeline = knowledge_base_table.build_rag_pipeline(retrieval_config)
-
-    # get response from rag pipeline
-    rag_response = rag_pipeline(query)
-    response = {
-        "message": {"content": rag_response.get("answer"), "context": rag_response.get("context"), "role": "assistant"}
-    }
-
-    return response
-
-
-def _handle_context_completion(knowledge_base_table: KnowledgeBaseTable, request):
-    # Used for semantic search.
-    query = request.json.get("query")
-    # Keyword search.
-    keywords = request.json.get("keywords")
-    # Metadata search.
-    metadata = request.json.get("metadata")
-    # Maximum amount of documents to return as context.
-    limit = request.json.get("limit", DEFAULT_CONTEXT_DOCUMENT_LIMIT)
-
-    # Use default distance function & column names for ID, content, & metadata, to keep things simple.
-    hybrid_search_df = knowledge_base_table.hybrid_search(query, keywords=keywords, metadata=metadata)
-
-    num_documents = len(hybrid_search_df.index)
-    context_documents = []
-    for i in range(limit):
-        if i >= num_documents:
-            break
-        row = hybrid_search_df.iloc[i]
-        context_documents.append({"id": row["id"], "content": row["content"], "rank": row["rank"]})
-
-    return {"documents": context_documents}
-
-
-@ns_conf.route("/<project_name>/knowledge_bases/<knowledge_base_name>/completions")
-@ns_conf.param("project_name", "Name of the project")
-@ns_conf.param("knowledge_base_name", "Name of the knowledge_base")
-class KnowledgeBaseCompletions(Resource):
-    @ns_conf.doc("knowledge_base_completions")
-    @api_endpoint_metrics("POST", "/knowledge_bases/knowledge_base/completions")
-    def post(self, project_name, knowledge_base_name):
-        """
-        Add support for LLM generation on the response from knowledge base. Default completion type is 'chat' unless specified.
-        """
-        if request.json.get("query") is None:
-            # "query" is used for semantic search for both completion types.
-            logger.error('Missing parameter "query" in POST body')
-            return http_error(
-                HTTPStatus.BAD_REQUEST, "Missing parameter", 'Must provide "query" parameter in POST body'
-            )
-
-        project_controller = ProjectController()
-        try:
-            project = project_controller.get(name=project_name)
-        except EntityNotExistsError:
-            # Project must exist.
-            logger.error("Project not found, please check the project name exists")
-            return http_error(
-                HTTPStatus.NOT_FOUND, "Project not found", f"Project with name {project_name} does not exist"
-            )
-
-        session = SessionController()
-        # Check if knowledge base exists
-        table = session.kb_controller.get_table(knowledge_base_name, project.id)
-        if table is None:
-            logger.error("Knowledge Base not found, please check the knowledge base name exists")
-            return http_error(
-                HTTPStatus.NOT_FOUND,
-                "Knowledge Base not found",
-                f"Knowledge Base with name {knowledge_base_name} does not exist",
-            )
-
-        completion_type = request.json.get("type", "chat")
-        if completion_type == "context":
-            return _handle_context_completion(table, request)
-        if completion_type == "chat":
-            return _handle_chat_completion(table, request)
-        return http_error(
-            HTTPStatus.BAD_REQUEST,
-            "Invalid parameter",
-            f'Completion type must be one of: "context", "chat". Received {completion_type}',
-        )
diff --git a/mindsdb/api/http/namespaces/sql.py b/mindsdb/api/http/namespaces/sql.py
index 934f89dbbe9..39e53cc431c 100644
--- a/mindsdb/api/http/namespaces/sql.py
+++ b/mindsdb/api/http/namespaces/sql.py
@@ -1,8 +1,9 @@
 import time
+from enum import Enum
 from http import HTTPStatus
 from collections import defaultdict
 
-from flask import request
+from flask import request, Response
 from flask_restx import Resource
 
 from mindsdb_sql_parser import parse_sql
@@ -12,15 +13,12 @@
 import mindsdb.utilities.profiler as profiler
 from mindsdb.api.http.utils import http_error
 from mindsdb.api.http.namespaces.configs.sql import ns_conf
-from mindsdb.api.mysql.mysql_proxy.mysql_proxy import SQLAnswer
 from mindsdb.api.mysql.mysql_proxy.classes.fake_mysql_proxy import FakeMysqlProxy
-from mindsdb.api.executor.data_types.response_type import (
-    RESPONSE_TYPE as SQL_RESPONSE_TYPE,
-)
+from mindsdb.api.executor.data_types.sql_answer import SQLAnswer
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE as SQL_RESPONSE_TYPE
 from mindsdb.api.executor.sql_query.result_set import ResultSet
-
-from mindsdb.integrations.utilities.query_traversal import query_traversal
 from mindsdb.api.executor.exceptions import ExecutorException, UnknownError
+from mindsdb.integrations.utilities.query_traversal import query_traversal
 from mindsdb.metrics.metrics import api_endpoint_metrics
 from mindsdb.utilities import log
 from mindsdb.utilities.config import Config
@@ -32,6 +30,12 @@
 logger = log.getLogger(__name__)
 
 
+class ReponseFormat(Enum):
+    DEFAULT = None
+    SSE = "sse"
+    JSONLINES = "jsonlines"
+
+
 @ns_conf.route("/query")
 @ns_conf.param("query", "Execute query")
 class Query(Resource):
@@ -45,8 +49,15 @@ def post(self):
         start_time = time.time()
         query = request.json["query"]
         context = request.json.get("context", {})
+
         if "params" in request.json:
             ctx.params = request.json["params"]
+
+        try:
+            response_format = ReponseFormat(request.json.get("response_format", None))
+        except ValueError:
+            return http_error(HTTPStatus.BAD_REQUEST, "Invalid stream format", "Please provide a valid stream format.")
+
         if isinstance(query, str) is False or isinstance(context, dict) is False:
             return http_error(HTTPStatus.BAD_REQUEST, "Wrong arguments", 'Please provide "query" with the request.')
         logger.debug(f"Incoming query: {query}")
@@ -55,8 +66,6 @@ def post(self):
             profiler.enable()
 
         error_type = None
-        error_code = None
-        error_text = None
         error_traceback = None
 
         profiler.set_meta(query=query, api="http", environment=Config().get("environment"))
@@ -95,58 +104,49 @@ def post(self):
                         }
 
                 query_response["context"] = mysql_proxy.get_context()
-
+                query_response = query_response, 200
             else:
                 try:
                     result: SQLAnswer = mysql_proxy.process_query(query)
-                    query_response: dict = result.dump_http_response()
                 except ExecutorException as e:
                     # classified error
                     error_type = "expected"
-                    query_response = {
-                        "type": SQL_RESPONSE_TYPE.ERROR,
-                        "error_code": 0,
-                        "error_message": str(e),
-                    }
+                    result = SQLAnswer(
+                        resp_type=SQL_RESPONSE_TYPE.ERROR,
+                        error_code=0,
+                        error_message=str(e),
+                    )
                     logger.warning(f"Error query processing: {e}")
                 except QueryError as e:
                     error_type = "expected" if e.is_expected else "unexpected"
-                    query_response = {
-                        "type": SQL_RESPONSE_TYPE.ERROR,
-                        "error_code": 0,
-                        "error_message": str(e),
-                    }
+                    result = SQLAnswer(
+                        resp_type=SQL_RESPONSE_TYPE.ERROR,
+                        error_code=0,
+                        error_message=str(e),
+                    )
                     if e.is_expected:
                         logger.warning(f"Query failed due to expected reason: {e}")
                     else:
                         logger.exception("Error query processing:")
-                except UnknownError as e:
-                    # unclassified
-                    error_type = "unexpected"
-                    query_response = {
-                        "type": SQL_RESPONSE_TYPE.ERROR,
-                        "error_code": 0,
-                        "error_message": str(e),
-                    }
-                    logger.exception("Error query processing:")
-
-                except Exception as e:
+                except (UnknownError, Exception) as e:
                     error_type = "unexpected"
-                    query_response = {
-                        "type": SQL_RESPONSE_TYPE.ERROR,
-                        "error_code": 0,
-                        "error_message": str(e),
-                    }
+                    result = SQLAnswer(
+                        resp_type=SQL_RESPONSE_TYPE.ERROR,
+                        error_code=0,
+                        error_message=str(e),
+                    )
                     logger.exception("Error query processing:")
 
-                if query_response.get("type") == SQL_RESPONSE_TYPE.ERROR:
-                    error_type = "expected"
-                    error_code = query_response.get("error_code")
-                    error_text = query_response.get("error_message")
-
                 context = mysql_proxy.get_context()
 
-                query_response["context"] = context
+                if response_format == ReponseFormat.JSONLINES:
+                    query_response = result.stream_http_response_jsonlines(context=context)
+                    query_response = Response(query_response, mimetype="application/jsonlines")
+                elif response_format == ReponseFormat.SSE:
+                    query_response = result.stream_http_response_sse(context=context)
+                    query_response = Response(query_response, mimetype="text/event-stream")
+                else:
+                    query_response = result.dump_http_response(context=context), 200
 
         hooks.after_api_query(
             company_id=ctx.company_id,
@@ -155,21 +155,23 @@ def post(self):
             command=None,
             payload=query,
             error_type=error_type,
-            error_code=error_code,
-            error_text=error_text,
+            error_code=result.error_code,
+            error_text=result.error_message,
             traceback=error_traceback,
         )
 
         end_time = time.time()
-        log_msg = f"SQL processed in {(end_time - start_time):.2f}s ({end_time:.2f}-{start_time:.2f}), result is {query_response['type']}"
-        if query_response["type"] is SQL_RESPONSE_TYPE.TABLE:
-            log_msg += f" ({len(query_response['data'])} rows), "
-        elif query_response["type"] is SQL_RESPONSE_TYPE.ERROR:
-            log_msg += f" ({query_response['error_message']}), "
-        log_msg += f"used handlers {ctx.used_handlers}"
+        log_msg = f"SQL processed in {(end_time - start_time):.2f}s ({end_time:.2f}-{start_time:.2f}), result is {result.type}, "
+        if result.type is SQL_RESPONSE_TYPE.TABLE and response_format is ReponseFormat.DEFAULT:
+            log_msg += f" one-piece result ({len(query_response[0]['data'])} rows), "
+        elif result.type is SQL_RESPONSE_TYPE.TABLE:
+            log_msg += f" {response_format} result, "
+        elif result.type is SQL_RESPONSE_TYPE.ERROR:
+            log_msg += f" ({result.error_message}), "
+        log_msg += f"used handlers: {ctx.used_handlers}"
         logger.debug(log_msg)
 
-        return query_response, 200
+        return query_response
 
 
 @ns_conf.route("/charter")
diff --git a/mindsdb/api/http/namespaces/tree.py b/mindsdb/api/http/namespaces/tree.py
index e9e1ee25fa7..87e03225dfd 100644
--- a/mindsdb/api/http/namespaces/tree.py
+++ b/mindsdb/api/http/namespaces/tree.py
@@ -39,7 +39,8 @@ def get(self, db_name):
         if isinstance(with_schemas, str):
             with_schemas = with_schemas.lower() in ("1", "true")
         else:
-            with_schemas = False
+            # Show all schemas by default for better UX
+            with_schemas = True
         db_name = db_name.lower()
         databases = ca.database_controller.get_dict()
         if db_name not in databases:
diff --git a/mindsdb/api/http/start.py b/mindsdb/api/http/start.py
index 9cfb8454c89..f2373ebb114 100644
--- a/mindsdb/api/http/start.py
+++ b/mindsdb/api/http/start.py
@@ -1,5 +1,6 @@
 import gc
 from importlib import import_module
+from contextlib import asynccontextmanager, AsyncExitStack
 
 gc.disable()
 
@@ -28,7 +29,7 @@ async def _health_check(request):
     return JSONResponse({"status": "ok"})
 
 
-def _mount_optional_api(name: str, mount_path: str, get_app_fn, routes):
+def _mount_optional_api(name: str, mount_path: str, get_app_fn, routes) -> object | None:
     try:
         optional_app = get_app_fn()
     except ImportError as exc:
@@ -41,8 +42,11 @@ def _mount_optional_api(name: str, mount_path: str, get_app_fn, routes):
         )
         return
 
-    optional_app.add_middleware(PATAuthMiddleware)
+    if name.upper() != "MCP" or config["api"]["mcp"]["oauth"]["enabled"] is False:
+        optional_app.add_middleware(PATAuthMiddleware)
+
     routes.append(Mount(mount_path, app=optional_app))
+    return optional_app
 
 
 def start(verbose, app: Flask = None, is_restart: bool = False):
@@ -58,23 +62,44 @@ def start(verbose, app: Flask = None, is_restart: bool = False):
     process_cache.init()
 
     routes = []
+    sub_apps = []
 
     # Health check FIRST - async endpoint that bypasses WSGI worker pool
     # This ensures health checks respond even when all workers are blocked
     routes.append(Route("/api/util/ping", _health_check, methods=["GET"]))
 
-    _mount_optional_api(
-        "A2A",
-        "/a2a",
-        lambda: import_module("mindsdb.api.a2a").get_a2a_app(),
-        routes,
-    )
-    _mount_optional_api(
-        "MCP",
-        "/mcp",
-        lambda: import_module("mindsdb.api.mcp").get_mcp_app(),
-        routes,
-    )
+    for name, path, factory in [
+        ("A2A", "/a2a", lambda: import_module("mindsdb.api.a2a").get_a2a_app()),
+        ("MCP", "/mcp", lambda: import_module("mindsdb.api.mcp").get_mcp_app()),
+    ]:
+        mounted = _mount_optional_api(name, path, factory, routes)
+        if mounted is not None:
+            sub_apps.append(mounted)
+
+    # RFC 9728: /.well-known/oauth-protected-resource must be at the server root,
+    # not under the /mcp mount, so we register it here before the Flask fallback.
+    try:
+        well_known_routes = import_module("mindsdb.api.mcp").get_mcp_well_known_routes()
+        routes.extend(well_known_routes)
+    except ImportError:
+        pass
+    except Exception as e:
+        logger.warning(f"Error during registering of mcp well-known routes: {e}")
+
+    @asynccontextmanager
+    async def lifespan(_):
+        """Propagate ASGI lifespan events to mounted sub-apps.
+
+        Starlette's Mount does not forward startup/shutdown lifespan events to
+        sub-applications automatically. This context manager manually enters the
+        lifespan context of each collected sub-app so their internal state
+        (e.g. StreamableHTTPSessionManager task group for MCP) is properly
+        initialized on startup and torn down on shutdown.
+        """
+        async with AsyncExitStack() as stack:
+            for sub_app in sub_apps:
+                await stack.enter_async_context(sub_app.router.lifespan_context(sub_app))
+            yield
 
     # Root app LAST so it won't shadow the others
     routes.append(
@@ -89,4 +114,10 @@ def start(verbose, app: Flask = None, is_restart: bool = False):
     )
 
     # Setting logging to None makes uvicorn use the existing logging configuration
-    uvicorn.run(Starlette(routes=routes, debug=verbose), host=host, port=int(port), log_level=None, log_config=None)
+    uvicorn.run(
+        Starlette(routes=routes, lifespan=lifespan, debug=verbose),
+        host=host,
+        port=int(port),
+        log_level=None,
+        log_config=None,
+    )
diff --git a/mindsdb/api/mcp/__init__.py b/mindsdb/api/mcp/__init__.py
index b5601a16e8b..3473a394e61 100644
--- a/mindsdb/api/mcp/__init__.py
+++ b/mindsdb/api/mcp/__init__.py
@@ -1,182 +1,3 @@
-import os
-from textwrap import dedent
-from typing import Any
-from contextlib import asynccontextmanager
-from collections.abc import AsyncIterator
-from dataclasses import dataclass
+from mindsdb.api.mcp.app import get_mcp_app, get_mcp_well_known_routes
 
-from mcp.server.fastmcp import FastMCP
-from mcp.server.transport_security import TransportSecuritySettings
-from starlette.requests import Request
-from starlette.responses import JSONResponse
-
-from mindsdb.api.mysql.mysql_proxy.classes.fake_mysql_proxy import FakeMysqlProxy
-from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE as SQL_RESPONSE_TYPE
-from mindsdb.interfaces.storage import db
-from mindsdb.utilities import log
-
-logger = log.getLogger(__name__)
-
-
-def _get_transport_security() -> TransportSecuritySettings:
-    default_hosts = ["localhost:*", "127.0.0.1:*"]
-    env_hosts = os.environ.get("MINDSDB_MCP_ALLOWED_HOSTS", "")
-    if env_hosts:
-        custom_hosts = [h.strip() for h in env_hosts.split(",") if h.strip()]
-        for host in custom_hosts:
-            if ":" not in host:
-                default_hosts.append(f"{host}:*")
-            default_hosts.append(host)
-        logger.info(f"MCP transport security allowed hosts: {default_hosts}")
-    return TransportSecuritySettings(allowed_hosts=default_hosts)
-
-
-@dataclass
-class AppContext:
-    db: Any
-
-
-@asynccontextmanager
-async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
-    """Manage application lifecycle with type-safe context"""
-    # Initialize on startup
-    db.init()
-    try:
-        yield AppContext(db=db)
-    finally:
-        # TODO: We need better way to handle this in storage/db.py
-        pass
-
-
-# Configure server with lifespan and transport security
-mcp = FastMCP(
-    "MindsDB",
-    lifespan=app_lifespan,
-    dependencies=["mindsdb"],
-    transport_security=_get_transport_security(),
-)
-
-
-# MCP Queries
-LISTING_QUERY = "SHOW DATABASES"
-
-
-query_tool_description = dedent("""\
-    Executes a SQL query against MindsDB.
-
-    A database must be specified either in the `context` parameter or directly in the query string (e.g., `SELECT * FROM my_database.my_table`). Queries like `SELECT * FROM my_table` will fail without a `context`.
-
-    Args:
-        query (str): The SQL query to execute.
-        context (dict, optional): The default database context. For example, `{"db": "my_postgres"}`.
-
-    Returns:
-        A dictionary describing the result.
-        - For a successful query with no data to return (e.g., an `UPDATE` statement), the response is `{"type": "ok"}`.
-        - If the query returns tabular data, the response is a dictionary containing `data` (a list of rows) and `column_names` (a list of column names). For example: `{"type": "table", "data": [[1, "a"], [2, "b"]], "column_names": ["column_a", "column_b"]}`.
-        - In case of an error, a response is `{"type": "error", "error_message": "the error message"}`.
-""")
-
-
-@mcp.tool(name="query", description=query_tool_description)
-def query(query: str, context: dict | None = None) -> dict[str, Any]:
-    """Execute a SQL query against MindsDB
-
-    Args:
-        query: The SQL query to execute
-        context: Optional context parameters for the query
-
-    Returns:
-        Dict containing the query results or error information
-    """
-
-    if context is None:
-        context = {}
-
-    logger.debug(f"Incoming MCP query: {query}")
-
-    mysql_proxy = FakeMysqlProxy()
-    mysql_proxy.set_context(context)
-
-    try:
-        result = mysql_proxy.process_query(query)
-
-        if result.type == SQL_RESPONSE_TYPE.OK:
-            return {"type": SQL_RESPONSE_TYPE.OK}
-
-        if result.type == SQL_RESPONSE_TYPE.TABLE:
-            return {
-                "type": SQL_RESPONSE_TYPE.TABLE,
-                "data": result.result_set.to_lists(json_types=True),
-                "column_names": [column.alias or column.name for column in result.result_set.columns],
-            }
-        else:
-            return {"type": SQL_RESPONSE_TYPE.ERROR, "error_code": 0, "error_message": "Unknown response type"}
-
-    except Exception as e:
-        logger.exception("Error processing query:")
-        return {"type": SQL_RESPONSE_TYPE.ERROR, "error_code": 0, "error_message": str(e)}
-
-
-list_databases_tool_description = (
-    "Returns a list of all database connections currently available in MindsDB. "
-    + "The tool takes no parameters and responds with a list of database names, "
-    + 'for example: ["my_postgres", "my_mysql", "test_db"].'
-)
-
-
-@mcp.tool(name="list_databases", description=list_databases_tool_description)
-def list_databases() -> list[str]:
-    """
-    List all databases in MindsDB
-
-    Returns:
-       list[str]: list of databases
-    """
-
-    mysql_proxy = FakeMysqlProxy()
-
-    try:
-        result = mysql_proxy.process_query(LISTING_QUERY)
-        if result.type == SQL_RESPONSE_TYPE.ERROR:
-            return {
-                "type": "error",
-                "error_code": result.error_code,
-                "error_message": result.error_message,
-            }
-
-        elif result.type == SQL_RESPONSE_TYPE.OK:
-            return {"type": "ok"}
-
-        elif result.type == SQL_RESPONSE_TYPE.TABLE:
-            data = result.result_set.to_lists(json_types=True)
-            data = [val[0] for val in data]
-            return data
-
-    except Exception as e:
-        logger.exception("Error while retrieving list of databases")
-        return {
-            "type": "error",
-            "error_code": 0,
-            "error_message": str(e),
-        }
-
-
-def _get_status(request: Request) -> JSONResponse:
-    """
-    Status endpoint that returns basic server information.
-    This endpoint can be used by the frontend to check if the MCP server is running.
-    """
-
-    status_info = {
-        "status": "ok",
-        "service": "mindsdb-mcp",
-    }
-
-    return JSONResponse(status_info)
-
-
-def get_mcp_app():
-    app = mcp.sse_app()
-    app.add_route("/status", _get_status, methods=["GET"])
-    return app
+__all__ = ["get_mcp_app", "get_mcp_well_known_routes"]
diff --git a/mindsdb/api/mcp/app.py b/mindsdb/api/mcp/app.py
new file mode 100644
index 00000000000..ea810595ac0
--- /dev/null
+++ b/mindsdb/api/mcp/app.py
@@ -0,0 +1,94 @@
+from contextlib import asynccontextmanager
+
+from starlette.applications import Starlette
+from starlette.middleware import Middleware
+from starlette.middleware.authentication import AuthenticationMiddleware
+from starlette.middleware.cors import CORSMiddleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.routing import Route
+
+from mcp.server.auth.middleware.bearer_auth import BearerAuthBackend
+from mcp.server.auth.middleware.auth_context import AuthContextMiddleware
+
+from mindsdb.utilities.config import config
+from mindsdb.api.common.middleware import RateLimitMiddleware
+from mindsdb.api.mcp.mcp_instance import mcp
+
+# region these imports required for correct initialization
+from mindsdb.api.mcp import tools  # noqa: F401
+from mindsdb.api.mcp import resources  # noqa: F401
+from mindsdb.api.mcp import prompts  # noqa: F401
+from mindsdb.api.mcp import completions  # noqa: F401
+# endregion
+
+
+def _get_status(request: Request) -> JSONResponse:
+    return JSONResponse({"status": "ok", "service": "mindsdb-mcp"})
+
+
+def get_mcp_app():
+    sse_starlette = mcp.sse_app()
+    http_starlette = mcp.streamable_http_app()
+
+    @asynccontextmanager
+    async def lifespan(_):
+        """Required for streamable_http to run task group"""
+        async with http_starlette.router.lifespan_context(http_starlette):
+            yield
+
+    middleware = []
+
+    # Preserve AuthenticationMiddleware from http_starlette so that
+    # RequireAuthMiddleware can read scope["user"] set by BearerAuthBackend.
+    if mcp._token_verifier is not None:
+        middleware = [
+            Middleware(AuthenticationMiddleware, backend=BearerAuthBackend(mcp._token_verifier)),
+            Middleware(AuthContextMiddleware),
+        ]
+
+    combined_app = Starlette(
+        routes=list(sse_starlette.routes) + list(http_starlette.routes),
+        middleware=middleware,
+        lifespan=lifespan,
+    )
+
+    # Rate limit should be added before CORS, so that CORS adds correct headers
+    if config["api"]["mcp"]["rate_limit"]["enabled"]:
+        combined_app.add_middleware(
+            RateLimitMiddleware,
+            requests_per_minute=config["api"]["mcp"]["rate_limit"]["requests_per_minute"],
+        )
+
+    if config["api"]["mcp"]["cors"]["enabled"]:
+        combined_app.add_middleware(
+            CORSMiddleware,
+            allow_origins=config["api"]["mcp"]["cors"]["allow_origins"],
+            allow_origin_regex=config["api"]["mcp"]["cors"]["allow_origin_regex"],
+            allow_methods=["GET", "POST", "DELETE", "OPTIONS"],
+            allow_headers=config["api"]["mcp"]["cors"]["allow_headers"],
+            expose_headers=["mcp-session-id"],
+        )
+
+    combined_app.add_route("/status", _get_status, methods=["GET"])
+
+    return combined_app
+
+
+def get_mcp_well_known_routes() -> list[Route]:
+    """Return OAuth protected resource metadata routes for mounting at the server root.
+
+    RFC 9728 requires /.well-known/oauth-protected-resource to be served at the
+    server root, not under the /mcp sub-path, so start.py registers these separately.
+    """
+    from mcp.server.auth.routes import create_protected_resource_routes
+
+    auth = mcp.settings.auth
+    if not auth or not auth.resource_server_url:
+        return []
+
+    return create_protected_resource_routes(
+        resource_url=auth.resource_server_url,
+        authorization_servers=[auth.issuer_url],
+        scopes_supported=auth.required_scopes,
+    )
diff --git a/mindsdb/api/mcp/completions.py b/mindsdb/api/mcp/completions.py
new file mode 100644
index 00000000000..94bf2abe2cd
--- /dev/null
+++ b/mindsdb/api/mcp/completions.py
@@ -0,0 +1,35 @@
+from mcp.types import Completion, PromptReference, ResourceTemplateReference
+
+from mindsdb.api.mcp.mcp_instance import mcp
+from mindsdb.api.executor.controllers.session_controller import SessionController
+from mindsdb.utilities.context import context as ctx
+from mindsdb.api.mcp.resources.schema import _get_database_names
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+@mcp.completion()
+async def handle_completion(ref, argument, context):
+    if not isinstance(ref, (ResourceTemplateReference, PromptReference)):
+        return None
+
+    try:
+        if argument.name == "database_name":
+            names = _get_database_names()
+            return Completion(values=[n for n in names if n.startswith(argument.value)])
+
+        if argument.name == "table_name":
+            database_name = (context.arguments or {}).get("database_name")
+            if not database_name:
+                return None
+            ctx.set_default()
+            session = SessionController()
+            datanode = session.datahub.get(database_name)
+            all_tables = datanode.get_tables()
+            names = [t.TABLE_NAME for t in all_tables]
+            return Completion(values=[n for n in names if n.startswith(argument.value)])
+    except Exception as e:
+        logger.info(f"Couldn't get completion for parameter {argument.name}: {e}")
+
+    return None
diff --git a/mindsdb/api/mcp/mcp_instance.py b/mindsdb/api/mcp/mcp_instance.py
new file mode 100644
index 00000000000..fa65ab47711
--- /dev/null
+++ b/mindsdb/api/mcp/mcp_instance.py
@@ -0,0 +1,36 @@
+from mcp.server.fastmcp import FastMCP
+from mcp.server.transport_security import TransportSecuritySettings
+
+from mindsdb.api.mcp.oauth import build_oauth_components
+from mindsdb.utilities.config import config
+
+
+def _create_mcp() -> FastMCP:
+    token_verifier, auth_settings = build_oauth_components()
+
+    dns_rebinding_protection = config["api"]["mcp"]["dns_rebinding_protection"]
+    transport_security = TransportSecuritySettings(enable_dns_rebinding_protection=dns_rebinding_protection)
+
+    return FastMCP(
+        name="MindsDB",
+        instructions=(
+            "MindsDB is a data platform that connects to external databases and data sources.\n"
+            "Use the available resources to discover connected databases and their schema,\n"
+            "then use the `query` tool to retrieve or manipulate data with SQL.\n"
+            "\n"
+            "Workflow:\n"
+            "1. Read `schema://databases` to list available data sources.\n"
+            "2. Read `schema://databases/{name}/tables` to explore tables in a source.\n"
+            "3. Read `schema://databases/{name}/tables/{table}/columns` to inspect columns.\n"
+            "4. Use the `query` tool to run SQL queries against the data."
+        ),
+        dependencies=["mindsdb"],
+        streamable_http_path="/streamable",
+        debug=False,
+        token_verifier=token_verifier,
+        auth=auth_settings,
+        transport_security=transport_security,
+    )
+
+
+mcp = _create_mcp()
diff --git a/mindsdb/api/mcp/oauth.py b/mindsdb/api/mcp/oauth.py
new file mode 100644
index 00000000000..0e21ffefe27
--- /dev/null
+++ b/mindsdb/api/mcp/oauth.py
@@ -0,0 +1,159 @@
+from typing import Any
+from urllib.parse import urljoin
+
+import httpx
+from pydantic import AnyHttpUrl
+from mcp.server.auth.settings import AuthSettings
+from mcp.server.auth.provider import AccessToken, TokenVerifier
+from mcp.shared.auth_utils import check_resource_allowed, resource_url_from_server_url
+
+from mindsdb.utilities.config import config
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+class IntrospectionTokenVerifier(TokenVerifier):
+    """Token verifier that uses OAuth 2.0 Token Introspection (RFC 7662).
+    Intended for use when MindsDB acts as a Resource Server and token
+    issuance is delegated to an external provider (e.g. Keycloak).
+
+    Args:
+        introspection_endpoint: Full URL of the RFC 7662 introspection endpoint.
+        server_url: Public URL of this MCP server (e.g. ``http://host:port/mcp/streamable``).
+            Used to derive the expected ``aud`` (audience) claim value.
+        client_id: OAuth client ID used to authenticate against the introspection endpoint.
+        client_secret: OAuth client secret used to authenticate against the introspection endpoint.
+    """
+
+    def __init__(
+        self,
+        introspection_endpoint: str,
+        server_url: str,
+        client_id: str,
+        client_secret: str,
+    ):
+        self.introspection_endpoint = introspection_endpoint
+        self.server_url = server_url
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.resource_url = resource_url_from_server_url(server_url)
+
+    async def verify_token(self, token: str) -> AccessToken | None:
+        """Verify a bearer token via the introspection endpoint.
+
+        Args:
+            token: Raw bearer token string extracted from the Authorization header.
+
+        Returns:
+            AccessToken: Populated access token on successful verification.
+            None: If the token is inactive, the audience is invalid, the endpoint
+                  is unreachable, or any other error occurs.
+        """
+        # to prevent SSRF attacks it must start from https, or be local server
+        if not self.introspection_endpoint.startswith(("https://", "http://localhost:", "http://127.0.0.1:")):
+            return None
+
+        timeout = httpx.Timeout(10.0, connect=5.0)
+        limits = httpx.Limits(max_connections=10, max_keepalive_connections=5)
+
+        async with httpx.AsyncClient(
+            timeout=timeout,
+            limits=limits,
+            verify=True,
+            follow_redirects=False,
+        ) as client:
+            try:
+                form_data = {
+                    "token": token,
+                    "client_id": self.client_id,
+                    "client_secret": self.client_secret,
+                }
+                headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+                response = await client.post(
+                    self.introspection_endpoint,
+                    data=form_data,
+                    headers=headers,
+                )
+
+                if response.status_code != 200:
+                    return None
+
+                data = response.json()
+                if not data.get("active", False):
+                    return None
+
+                if not self._validate_resource(data):
+                    return None
+
+                return AccessToken(
+                    token=token,
+                    client_id=data.get("client_id", "unknown"),
+                    scopes=data.get("scope", "").split() if data.get("scope") else [],
+                    expires_at=data.get("exp"),
+                    resource=self.resource_url,
+                )
+
+            except Exception as e:
+                logger.error(f"Error during token verification: {e}")
+                return None
+
+    def _validate_resource(self, token_data: dict[str, Any]) -> bool:
+        """Validate that the token was issued for this resource server (RFC 8707).
+
+        Args:
+            token_data: Parsed JSON response from the introspection endpoint.
+
+        Returns:
+            bool: True if at least one audience entry matches this server's resource URL,
+                  False if ``aud`` is missing or no entry matches.
+        """
+        if not self.server_url or not self.resource_url:
+            return False
+
+        aud: list[str] | str | None = token_data.get("aud")
+        if isinstance(aud, list):
+            return any(check_resource_allowed(self.resource_url, a) for a in aud)
+        if isinstance(aud, str):
+            return check_resource_allowed(self.resource_url, aud)
+        return False
+
+
+def build_oauth_components() -> tuple[IntrospectionTokenVerifier, AuthSettings] | tuple[None, None]:
+    """Build token verifier and auth settings from the OAuth config section.
+
+    Returns:
+        tuple[IntrospectionTokenVerifier, AuthSettings]: Token verifier and auth settings ready
+                                                         to pass to FastMCP if OAuth is enabled.
+        tuple[None, None]: If OAuth ``enabled`` is False or not set.
+    """
+    oauth_cfg = config["api"]["mcp"]["oauth"]
+    if not oauth_cfg.get("enabled", False):
+        return None, None
+
+    host = config["api"]["http"]["host"]
+    port = config["api"]["http"]["port"]
+    mcp_endpoint_url = f"http://{host}:{port}/mcp/streamable"
+
+    issuer_url = oauth_cfg.get("issuer_url", "").rstrip("/") + "/"
+    client_id = oauth_cfg.get("client_id", "")
+    client_secret = oauth_cfg.get("client_secret", "")
+    scope = oauth_cfg.get("scope", "mcp:tools")
+
+    introspection_endpoint = urljoin(issuer_url, "protocol/openid-connect/token/introspect")
+
+    token_verifier = IntrospectionTokenVerifier(
+        introspection_endpoint=introspection_endpoint,
+        server_url=mcp_endpoint_url,
+        client_id=client_id,
+        client_secret=client_secret,
+    )
+
+    auth_settings = AuthSettings(
+        issuer_url=AnyHttpUrl(issuer_url),
+        required_scopes=[scope],
+        resource_server_url=AnyHttpUrl(mcp_endpoint_url),
+    )
+
+    return token_verifier, auth_settings
diff --git a/mindsdb/api/mcp/prompts/__init__.py b/mindsdb/api/mcp/prompts/__init__.py
new file mode 100644
index 00000000000..437673b53d3
--- /dev/null
+++ b/mindsdb/api/mcp/prompts/__init__.py
@@ -0,0 +1 @@
+from mindsdb.api.mcp.prompts import sample_table  # noqa: F401
diff --git a/mindsdb/api/mcp/prompts/sample_table.py b/mindsdb/api/mcp/prompts/sample_table.py
new file mode 100644
index 00000000000..2473715aa7d
--- /dev/null
+++ b/mindsdb/api/mcp/prompts/sample_table.py
@@ -0,0 +1,21 @@
+from mcp.types import TextContent
+
+from mindsdb.api.mcp.mcp_instance import mcp
+
+
+@mcp.prompt(name="sample_table", description="Fetch 5 sample rows from a table and describe its structure.")
+def sample_table(database_name: str, table_name: str) -> list[TextContent]:
+    return [
+        TextContent(
+            type="text",
+            text=(
+                f"Use the `query` tool to fetch 5 sample rows from the table `{table_name}` "
+                f"in database `{database_name}`:\n\n"
+                f"```sql\n"
+                f"SELECT * FROM `{database_name}`.`{table_name}` LIMIT 5;\n"
+                f"```\n\n"
+                f"After getting the results, briefly describe the table structure "
+                f"and what kind of data it contains."
+            ),
+        )
+    ]
diff --git a/mindsdb/api/mcp/resources/__init__.py b/mindsdb/api/mcp/resources/__init__.py
new file mode 100644
index 00000000000..5cd0b60720d
--- /dev/null
+++ b/mindsdb/api/mcp/resources/__init__.py
@@ -0,0 +1 @@
+from mindsdb.api.mcp.resources import schema  # noqa: F401
diff --git a/mindsdb/api/mcp/resources/schema.py b/mindsdb/api/mcp/resources/schema.py
new file mode 100644
index 00000000000..6986c7dd420
--- /dev/null
+++ b/mindsdb/api/mcp/resources/schema.py
@@ -0,0 +1,136 @@
+from pydantic import BaseModel
+
+from mindsdb.api.mcp.mcp_instance import mcp
+from mindsdb.api.executor.controllers.session_controller import SessionController
+from mindsdb.utilities.context import context as ctx
+from mindsdb.integrations.libs.response import TableResponse, ErrorResponse
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+
+
+class TableInfo(BaseModel):
+    TABLE_NAME: str
+    TABLE_TYPE: str
+    TABLE_SCHEMA: str
+
+
+class ColumnInfo(BaseModel):
+    COLUMN_NAME: str
+    MYSQL_DATA_TYPE: str
+
+
+class KnowledgeBaseInfo(BaseModel):
+    name: str
+    project: str
+    metadata_columns: list[str]
+    content_columns: list[str]
+    id_column: str
+
+
+def _get_database_names() -> list[str]:
+    ctx.set_default()
+    session = SessionController()
+    databases = session.database_controller.get_list()
+    return [x["name"] for x in databases if x["type"] == "data"]
+
+
+@mcp.resource(
+    "schema://databases",
+    mime_type="application/json",
+    description=(
+        "Initial list of connected data source names available for querying. "
+        "This resource may be cached by the client. "
+        "To get the current list of databases during a session, use the `query` tool: "
+        "SHOW DATABASES"
+    ),
+)
+def list_databases() -> list[str]:
+    return _get_database_names()
+
+
+@mcp.resource(
+    "schema://databases/{database_name}/tables",
+    mime_type="application/json",
+    description=(
+        "Initial list of tables in the specified connected database. "
+        "This resource may be cached by the client. "
+        "To get the current list of tables during a session (e.g. after CREATE/DROP TABLE), "
+        "use the `query` tool: "
+        "SHOW TABLES FROM {database_name}"
+    ),
+)
+def db_tables(database_name: str) -> list[TableInfo]:
+    ctx.set_default()
+    session = SessionController()
+    datanode = session.datahub.get(database_name)
+    if datanode is None:
+        raise ValueError(f"Database '{database_name}' is not found.")
+    all_tables = datanode.get_tables()
+    all_tables = [
+        {
+            "TABLE_NAME": table.TABLE_NAME,
+            "TABLE_TYPE": table.TABLE_TYPE,
+            "TABLE_SCHEMA": table.TABLE_SCHEMA,
+        }
+        for table in all_tables
+    ]
+    return all_tables
+
+
+@mcp.resource(
+    "schema://databases/{database_name}/tables/{table_name}/columns",
+    mime_type="application/json",
+    description=(
+        "Initial column names and types for a specific table in a connected database. "
+        "This resource may be cached by the client. "
+        "To get the current column list during a session (e.g. after ALTER TABLE), "
+        "use the `query` tool: "
+        "SELECT COLUMN_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS "
+        "WHERE TABLE_SCHEMA = '{database_name}' AND TABLE_NAME = '{table_name}'"
+    ),
+)
+def db_table_columns(database_name: str, table_name: str) -> list[ColumnInfo]:
+    ctx.set_default()
+    session = SessionController()
+    handler = session.integration_controller.get_data_handler(database_name)
+    columns_answer = handler.get_columns(table_name)
+
+    if isinstance(columns_answer, TableResponse):
+        if columns_answer.type != RESPONSE_TYPE.COLUMNS_TABLE:
+            raise ValueError(
+                "Database returned a successful response, but the column list does not match the expected format"
+            )
+        df = columns_answer.fetchall()
+        response = df[["COLUMN_NAME", "MYSQL_DATA_TYPE"]].to_dict(orient="records")
+        return response
+    if isinstance(columns_answer, ErrorResponse):
+        raise ValueError(columns_answer.error_message)
+    raise ValueError(f"Unexpected handler response type: {columns_answer}")
+
+
+@mcp.resource(
+    "schema://knowledge_bases",
+    description=(
+        "Initial list of knowledge bases with their project, column configuration, and ID column. "
+        "This resource may be cached by the client. "
+        "To get the current list of knowledge bases during a session, use the `query` tool: "
+        "SHOW KNOWLEDGE BASES"
+    ),
+)
+def list_knowledge_bases() -> list[KnowledgeBaseInfo]:
+    ctx.set_default()
+    session = SessionController()
+    project_names = session.datahub.get_projects_names()
+    result = []
+    for project_name in project_names:
+        kbs = session.kb_controller.list(project_name)
+        for kb in kbs:
+            result.append(
+                {
+                    "name": kb.get("name"),
+                    "project": kb.get("project"),
+                    "metadata_columns": kb.get("metadata_columns"),
+                    "content_columns": kb.get("content_columns"),
+                    "id_column": kb.get("id_column"),
+                }
+            )
+    return result
diff --git a/mindsdb/api/mcp/tools/__init__.py b/mindsdb/api/mcp/tools/__init__.py
new file mode 100644
index 00000000000..a07edf06817
--- /dev/null
+++ b/mindsdb/api/mcp/tools/__init__.py
@@ -0,0 +1 @@
+from mindsdb.api.mcp.tools import query  # noqa: F401
diff --git a/mindsdb/api/mcp/tools/query.py b/mindsdb/api/mcp/tools/query.py
new file mode 100644
index 00000000000..42026e32b1f
--- /dev/null
+++ b/mindsdb/api/mcp/tools/query.py
@@ -0,0 +1,60 @@
+from textwrap import dedent
+from typing import Annotated
+
+from pydantic import Field
+
+from mindsdb.api.mcp.mcp_instance import mcp
+from mindsdb.api.mcp.types import ErrorResponse, QueryResponseAnswer, response_adapter
+from mindsdb.api.mysql.mysql_proxy.mysql_proxy import SQLAnswer
+from mindsdb.api.mysql.mysql_proxy.classes.fake_mysql_proxy import FakeMysqlProxy
+from mindsdb.utilities.context import context as ctx
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+query_tool_description = dedent("""\
+    Execute a SQL query against MindsDB and return the result.
+
+    Queries use MySQL syntax. Use fully qualified names (`database`.`table`) or set `context` to specify
+    the default database. Use backticks (`) to quote identifiers that are reserved words or contain
+    special characters.
+
+    Returns one of:
+    - `{"type": "ok"}` — for statements with no output (INSERT, UPDATE, etc.)
+    - `{"type": "table", "column_names": [...], "data": [[...], ...]}` — for SELECT results
+    - `{"type": "error", "error_message": "..."}` — on failure
+""")
+
+
+@mcp.tool(name="query", description=query_tool_description)
+def query(
+    query: Annotated[str, Field(description="SQL query to execute against MindsDB.")],
+    context: Annotated[
+        dict | None,
+        Field(
+            description=(
+                'Default database context, e.g. {"db": "my_postgres"}. '
+                "Required if the query does not use fully qualified table names."
+            )
+        ),
+    ] = None,
+) -> QueryResponseAnswer:
+    ctx.set_default()
+
+    if context is None:
+        context = {}
+
+    logger.debug(f"Incoming MCP query: {query}")
+
+    mysql_proxy = FakeMysqlProxy()
+    mysql_proxy.set_context(context)
+
+    try:
+        result: SQLAnswer = mysql_proxy.process_query(query)
+        query_response: dict = result.dump_http_response()
+    except Exception as e:
+        logger.exception("Error processing query:")
+        return ErrorResponse(type="error", error_code=0, error_message=str(e))
+
+    return response_adapter.validate_python(query_response)
diff --git a/mindsdb/api/mcp/types.py b/mindsdb/api/mcp/types.py
new file mode 100644
index 00000000000..0275742116f
--- /dev/null
+++ b/mindsdb/api/mcp/types.py
@@ -0,0 +1,25 @@
+from typing import Annotated, Literal, Union
+
+from pydantic import BaseModel, Field, TypeAdapter
+
+
+class OkResponse(BaseModel):
+    type: Literal["ok"]
+    affected_rows: int | None = None
+
+
+class ErrorResponse(BaseModel):
+    type: Literal["error"]
+    error_code: int
+    error_message: str
+
+
+class TableResponse(BaseModel):
+    type: Literal["table"]
+    column_names: list[str]
+    data: list[list]
+
+
+QueryResponseAnswer = Annotated[Union[OkResponse, ErrorResponse, TableResponse], Field(discriminator="type")]
+
+response_adapter = TypeAdapter(QueryResponseAnswer)
diff --git a/mindsdb/api/mysql/mysql_proxy/executor/mysql_executor.py b/mindsdb/api/mysql/mysql_proxy/executor/mysql_executor.py
index 6f3b06387e4..ec9c122f3d6 100644
--- a/mindsdb/api/mysql/mysql_proxy/executor/mysql_executor.py
+++ b/mindsdb/api/mysql/mysql_proxy/executor/mysql_executor.py
@@ -3,7 +3,7 @@
 from mindsdb_sql_parser.ast.base import ASTNode
 import mindsdb.utilities.profiler as profiler
 from mindsdb.api.executor.sql_query import SQLQuery
-from mindsdb.api.executor.sql_query.result_set import Column
+from mindsdb.utilities.types.column import Column
 from mindsdb.api.executor.planner import utils as planner_utils
 from mindsdb.api.executor.data_types.answer import ExecuteAnswer
 from mindsdb.api.executor.command_executor import ExecuteCommands
diff --git a/mindsdb/api/mysql/mysql_proxy/mysql_proxy.py b/mindsdb/api/mysql/mysql_proxy/mysql_proxy.py
index 5fd02915246..8f691db994c 100644
--- a/mindsdb/api/mysql/mysql_proxy/mysql_proxy.py
+++ b/mindsdb/api/mysql/mysql_proxy/mysql_proxy.py
@@ -22,8 +22,6 @@
 import traceback
 import logging
 from functools import partial
-from typing import List
-from dataclasses import dataclass
 
 import mindsdb.utilities.hooks as hooks
 import mindsdb.utilities.profiler as profiler
@@ -65,11 +63,12 @@
     getConstName,
 )
 from mindsdb.api.executor.data_types.answer import ExecuteAnswer
+from mindsdb.api.executor.data_types.sql_answer import SQLAnswer
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
 from mindsdb.api.executor import exceptions as executor_exceptions
 from mindsdb.api.common.middleware import check_auth
-from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
-from mindsdb.api.executor.sql_query.result_set import Column, ResultSet
+from mindsdb.api.executor.sql_query.result_set import ResultSet
+from mindsdb.utilities.types.column import Column
 from mindsdb.utilities import log
 from mindsdb.utilities.config import config
 from mindsdb.utilities.context import context as ctx
@@ -93,44 +92,6 @@ def empty_fn():
     pass
 
 
-@dataclass
-class SQLAnswer:
-    resp_type: RESPONSE_TYPE = RESPONSE_TYPE.OK
-    result_set: ResultSet | None = None
-    status: int | None = None
-    state_track: List[List] | None = None
-    error_code: int | None = None
-    error_message: str | None = None
-    affected_rows: int | None = None
-    mysql_types: list[MYSQL_DATA_TYPE] | None = None
-
-    @property
-    def type(self):
-        return self.resp_type
-
-    def dump_http_response(self) -> dict:
-        if self.resp_type == RESPONSE_TYPE.OK:
-            return {
-                "type": self.resp_type,
-                "affected_rows": self.affected_rows,
-            }
-        elif self.resp_type in (RESPONSE_TYPE.TABLE, RESPONSE_TYPE.COLUMNS_TABLE):
-            data = self.result_set.to_lists(json_types=True)
-            return {
-                "type": RESPONSE_TYPE.TABLE,
-                "data": data,
-                "column_names": [column.alias or column.name for column in self.result_set.columns],
-            }
-        elif self.resp_type == RESPONSE_TYPE.ERROR:
-            return {
-                "type": RESPONSE_TYPE.ERROR,
-                "error_code": self.error_code or 0,
-                "error_message": self.error_message,
-            }
-        else:
-            raise ValueError(f"Unsupported response type for dump HTTP response: {self.resp_type}")
-
-
 class MysqlTCPServer(SocketServer.ThreadingTCPServer):
     """
     Custom TCP Server with increased request queue size
diff --git a/mindsdb/api/mysql/mysql_proxy/utilities/dump.py b/mindsdb/api/mysql/mysql_proxy/utilities/dump.py
index f580c7bf714..82fa0a5232f 100644
--- a/mindsdb/api/mysql/mysql_proxy/utilities/dump.py
+++ b/mindsdb/api/mysql/mysql_proxy/utilities/dump.py
@@ -9,7 +9,8 @@
 import pandas as pd
 from pandas.api import types as pd_types
 
-from mindsdb.api.executor.sql_query.result_set import ResultSet, get_mysql_data_type_from_series, Column
+from mindsdb.api.executor.sql_query.result_set import ResultSet, get_mysql_data_type_from_series
+from mindsdb.utilities.types.column import Column
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import (
     MYSQL_DATA_TYPE,
     DATA_C_TYPE_MAP,
diff --git a/mindsdb/integrations/handlers/ag2_handler/README.md b/mindsdb/integrations/handlers/ag2_handler/README.md
new file mode 100644
index 00000000000..aa2fe180d50
--- /dev/null
+++ b/mindsdb/integrations/handlers/ag2_handler/README.md
@@ -0,0 +1,99 @@
+# AG2 Handler
+
+This handler integrates [AG2](https://ag2.ai), an open-source multi-agent framework, with MindsDB. It enables creating and querying multi-agent teams via SQL.
+
+AG2 (formerly AutoGen) has 500K+ monthly PyPI downloads, 4,300+ GitHub stars, and 400+ contributors.
+
+## Setup
+
+### Install dependencies
+
+```bash
+pip install "ag2[openai]>=0.11.4,<1.0"
+```
+
+### Create an ML engine
+
+```sql
+CREATE ML_ENGINE ag2_engine
+FROM ag2
+USING openai_api_key = 'your-key-here';
+```
+
+## Usage
+
+### Create a multi-agent model
+
+```sql
+CREATE MODEL research_team
+PREDICT answer
+USING
+    engine = 'ag2_engine',
+    agents = '[
+        {"name": "Researcher", "system_message": "You research topics and provide key facts with sources."},
+        {"name": "Writer", "system_message": "You write clear, engaging summaries from research findings."},
+        {"name": "Critic", "system_message": "You review content for accuracy. Say TERMINATE when approved."}
+    ]',
+    max_rounds = 8,
+    speaker_selection = 'auto';
+```
+
+### Query the agents
+
+```sql
+SELECT answer
+FROM research_team
+WHERE question = 'What are the main benefits of retrieval-augmented generation?';
+```
+
+### Batch queries
+
+```sql
+SELECT t.question, m.answer
+FROM my_questions AS t
+JOIN research_team AS m;
+```
+
+## Configuration
+
+### Engine arguments
+
+| Parameter | Required | Default | Description |
+|-----------|----------|---------|-------------|
+| `openai_api_key` | Yes | — | API key for the agents' LLM |
+| `model` | No | `gpt-4o-mini` | LLM model name |
+| `api_type` | No | `openai` | API type (openai, anthropic, etc.) |
+| `api_base` | No | — | Custom API base URL |
+
+### Model arguments
+
+| Parameter | Required | Default | Description |
+|-----------|----------|---------|-------------|
+| `agents` | No | Single assistant | JSON list of agent definitions |
+| `max_rounds` | No | `8` | Max GroupChat rounds |
+| `speaker_selection` | No | `auto` | Speaker selection: auto, round_robin, random |
+| `mode` | No | `groupchat` | Mode: single or groupchat |
+
+### Agent definition format
+
+```json
+[
+    {
+        "name": "AgentName",
+        "system_message": "Agent's role and instructions."
+    }
+]
+```
+
+## Modes
+
+- **single**: One assistant agent handles the query directly
+- **groupchat**: Multiple agents collaborate via GroupChat with automatic speaker selection
+
+## Describe
+
+```sql
+DESCRIBE MODEL research_team;
+DESCRIBE MODEL research_team ATTRIBUTE args;
+DESCRIBE MODEL research_team ATTRIBUTE agents;
+```
diff --git a/mindsdb/integrations/handlers/ag2_handler/__about__.py b/mindsdb/integrations/handlers/ag2_handler/__about__.py
new file mode 100644
index 00000000000..34ad701e213
--- /dev/null
+++ b/mindsdb/integrations/handlers/ag2_handler/__about__.py
@@ -0,0 +1,9 @@
+__title__ = "MindsDB AG2 handler"
+__package_name__ = "mindsdb_ag2_handler"
+__version__ = "0.0.1"
+__description__ = "MindsDB handler for AG2 multi-agent framework"
+__author__ = "Faridun Mirzoev"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2024- mindsdb"
diff --git a/mindsdb/integrations/handlers/ag2_handler/__init__.py b/mindsdb/integrations/handlers/ag2_handler/__init__.py
new file mode 100644
index 00000000000..0791ce71b60
--- /dev/null
+++ b/mindsdb/integrations/handlers/ag2_handler/__init__.py
@@ -0,0 +1,32 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+from .creation_args import creation_args
+from .model_using_args import model_using_args
+
+try:
+    from .ag2_handler import AG2Handler as Handler
+
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "AG2"
+name = "ag2"
+type = HANDLER_TYPE.ML
+icon_path = "icon.svg"
+permanent = False
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "import_error",
+    "icon_path",
+    "creation_args",
+    "model_using_args",
+]
diff --git a/mindsdb/integrations/handlers/ag2_handler/ag2_handler.py b/mindsdb/integrations/handlers/ag2_handler/ag2_handler.py
new file mode 100644
index 00000000000..b67b41936a1
--- /dev/null
+++ b/mindsdb/integrations/handlers/ag2_handler/ag2_handler.py
@@ -0,0 +1,260 @@
+"""AG2 multi-agent handler for MindsDB.
+
+Enables creating and querying AG2 multi-agent GroupChats via SQL.
+
+Usage:
+    -- Create engine
+    CREATE ML_ENGINE ag2_engine
+    FROM ag2
+    USING openai_api_key = 'sk-...';
+
+    -- Create model (agent team)
+    CREATE MODEL my_agent_team
+    PREDICT answer
+    USING
+        engine = 'ag2_engine',
+        agents = '[
+            {"name": "Researcher", "system_message": "You research topics thoroughly."},
+            {"name": "Writer", "system_message": "You write clear summaries."},
+            {"name": "Critic", "system_message": "You review for accuracy. Say TERMINATE when done."}
+        ]',
+        max_rounds = 8;
+
+    -- Query the agent team
+    SELECT answer
+    FROM my_agent_team
+    WHERE question = 'Explain how transformers work';
+"""
+
+import json
+import os
+from typing import Any, Dict, Optional
+
+import pandas as pd
+
+from mindsdb.integrations.libs.base import BaseMLEngine
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+class AG2Handler(BaseMLEngine):
+    """Handler for AG2 multi-agent framework."""
+
+    name = "ag2"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.generative = True
+
+    def create_engine(self, connection_args: Dict) -> None:
+        """Validate engine connection args (API key)."""
+        api_key = connection_args.get("openai_api_key") or os.environ.get("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("openai_api_key is required. Pass it in USING clause or set OPENAI_API_KEY env var.")
+
+        try:
+            from autogen import LLMConfig
+
+            model = connection_args.get("model", "gpt-4o-mini")
+            api_type = connection_args.get("api_type", "openai")
+
+            config = {"model": model, "api_key": api_key, "api_type": api_type}
+            if connection_args.get("api_base"):
+                config["base_url"] = connection_args["api_base"]
+
+            LLMConfig(config)
+        except ImportError:
+            raise ImportError('AG2 is not installed. Run: pip install "ag2[openai]>=0.11.4,<1.0"')
+        except Exception as e:
+            raise ValueError(f"Failed to validate AG2 configuration: {e}")
+
+    @staticmethod
+    def create_validation(target: str, args: Optional[Dict] = None, **kwargs: Any) -> None:
+        """Validate model creation args."""
+        using_args = args.get("using", {})
+
+        agents_json = using_args.get("agents")
+        if agents_json:
+            try:
+                agents = json.loads(agents_json) if isinstance(agents_json, str) else agents_json
+                if not isinstance(agents, list) or len(agents) == 0:
+                    raise ValueError("'agents' must be a non-empty JSON list.")
+                for agent in agents:
+                    if "name" not in agent:
+                        raise ValueError("Each agent must have a 'name' field.")
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Invalid 'agents' JSON: {e}")
+
+        mode = using_args.get("mode", "groupchat")
+        if mode not in ("single", "groupchat"):
+            raise ValueError(f"Invalid mode '{mode}'. Must be 'single' or 'groupchat'.")
+
+        selection = using_args.get("speaker_selection", "auto")
+        if selection not in ("auto", "round_robin", "random"):
+            raise ValueError(f"Invalid speaker_selection '{selection}'. Must be 'auto', 'round_robin', or 'random'.")
+
+    def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
+        """Store model configuration."""
+        using_args = args.get("using", {})
+        using_args["target"] = target
+        self.model_storage.json_set("args", using_args)
+
+    def predict(self, df: pd.DataFrame, args: Optional[Dict] = None) -> pd.DataFrame:
+        """Run AG2 agents for each row in the input DataFrame.
+
+        Expects a 'question' column. Returns a DataFrame with the target column.
+        """
+        from autogen import LLMConfig
+
+        stored_args = self.model_storage.json_get("args")
+        predict_args = args.get("predict_params", {}) if args else {}
+        merged_args = {**stored_args, **predict_args}
+
+        # Build LLM config from engine args
+        engine_args = self.engine_storage.get_connection_args()
+        model = merged_args.get("model", engine_args.get("model", "gpt-4o-mini"))
+        api_type = merged_args.get("api_type", engine_args.get("api_type", "openai"))
+
+        api_key = engine_args.get("openai_api_key") or os.environ.get("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("openai_api_key not found. Pass it in USING clause or set OPENAI_API_KEY env var.")
+
+        config = {
+            "model": model,
+            "api_key": api_key,
+            "api_type": api_type,
+        }
+        if engine_args.get("api_base"):
+            config["base_url"] = engine_args["api_base"]
+
+        llm_config = LLMConfig(config)
+
+        # Parse agent definitions
+        agents_json = merged_args.get("agents")
+        if agents_json:
+            agent_defs = json.loads(agents_json) if isinstance(agents_json, str) else agents_json
+        else:
+            agent_defs = [
+                {
+                    "name": "Assistant",
+                    "system_message": (
+                        "You are a helpful AI assistant. Provide clear, comprehensive "
+                        "answers. Reply TERMINATE when the task is complete."
+                    ),
+                },
+            ]
+
+        mode = merged_args.get("mode", "groupchat" if len(agent_defs) > 1 else "single")
+        max_rounds = int(merged_args.get("max_rounds", 8))
+        speaker_selection = merged_args.get("speaker_selection", "auto")
+
+        # Determine question column
+        question_col = "question"
+        if question_col not in df.columns:
+            question_col = df.columns[0]
+
+        target = merged_args.get("target", "answer")
+
+        results = []
+        for _, row in df.iterrows():
+            question = str(row[question_col])
+
+            try:
+                answer = self._run_agents(
+                    llm_config=llm_config,
+                    agent_defs=agent_defs,
+                    question=question,
+                    mode=mode,
+                    max_rounds=max_rounds,
+                    speaker_selection=speaker_selection,
+                )
+                results.append({target: answer})
+            except Exception as e:
+                logger.error(f"AG2 prediction error: {e}")
+                results.append({target: f"Error: {e}"})
+
+        return pd.DataFrame(results)
+
+    def _run_agents(
+        self,
+        llm_config,
+        agent_defs: list,
+        question: str,
+        mode: str,
+        max_rounds: int,
+        speaker_selection: str,
+    ) -> str:
+        """Execute AG2 agent conversation and return the final answer."""
+        from autogen import AssistantAgent, GroupChat, GroupChatManager, UserProxyAgent
+
+        agents = []
+        for agent_def in agent_defs:
+            agent = AssistantAgent(
+                name=agent_def["name"],
+                system_message=agent_def.get(
+                    "system_message",
+                    f"You are {agent_def['name']}. Be helpful and concise.",
+                ),
+                llm_config=llm_config,
+            )
+            agents.append(agent)
+
+        user_proxy = UserProxyAgent(
+            name="User",
+            human_input_mode="NEVER",
+            max_consecutive_auto_reply=0,
+            code_execution_config=False,
+        )
+
+        if mode == "single":
+            user_proxy.run(agents[0], message=question).process()
+            messages = agents[0].chat_messages.get(user_proxy, [])
+        else:
+            group_chat = GroupChat(
+                agents=[user_proxy] + agents,
+                messages=[],
+                max_round=max_rounds,
+                speaker_selection_method=speaker_selection,
+            )
+            manager = GroupChatManager(
+                groupchat=group_chat,
+                llm_config=llm_config,
+            )
+            user_proxy.run(manager, message=question).process()
+            messages = group_chat.messages
+
+        # Extract last non-user, non-empty message as the answer
+        answer = ""
+        for msg in reversed(messages):
+            content = msg.get("content", "").strip()
+            name = msg.get("name", "")
+            if content and name != "User":
+                answer = content.replace("TERMINATE", "").strip()
+                if answer:
+                    break
+
+        return answer or "No answer generated."
+
+    def describe(self, attribute: Optional[str] = None) -> pd.DataFrame:
+        """Describe the model configuration."""
+        stored_args = self.model_storage.json_get("args")
+
+        if attribute == "args":
+            return pd.DataFrame([stored_args])
+        elif attribute == "agents":
+            agents_json = stored_args.get("agents", "[]")
+            agents = json.loads(agents_json) if isinstance(agents_json, str) else agents_json
+            return pd.DataFrame(agents) if agents else pd.DataFrame()
+        else:
+            agents_raw = stored_args.get("agents", "[]")
+            agents = json.loads(agents_raw) if isinstance(agents_raw, str) else agents_raw
+            info = {
+                "name": "AG2 Multi-Agent Handler",
+                "version": "0.0.1",
+                "mode": stored_args.get("mode", "groupchat"),
+                "max_rounds": stored_args.get("max_rounds", 8),
+                "speaker_selection": stored_args.get("speaker_selection", "auto"),
+                "num_agents": len(agents) if isinstance(agents, list) else 0,
+            }
+            return pd.DataFrame([info])
diff --git a/mindsdb/integrations/handlers/ag2_handler/creation_args.py b/mindsdb/integrations/handlers/ag2_handler/creation_args.py
new file mode 100644
index 00000000000..a7a14d7a4c2
--- /dev/null
+++ b/mindsdb/integrations/handlers/ag2_handler/creation_args.py
@@ -0,0 +1,31 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+creation_args = OrderedDict(
+    openai_api_key={
+        "type": ARG_TYPE.STR,
+        "description": "OpenAI API key for the agents LLM backend. Falls back to OPENAI_API_KEY env var.",
+        "required": False,
+        "label": "OpenAI API key",
+        "secret": True,
+    },
+    model={
+        "type": ARG_TYPE.STR,
+        "description": "LLM model name (default: gpt-4o-mini).",
+        "required": False,
+        "label": "Model name",
+    },
+    api_type={
+        "type": ARG_TYPE.STR,
+        "description": "LLM API type: openai, anthropic, bedrock, etc. (default: openai).",
+        "required": False,
+        "label": "API type",
+    },
+    api_base={
+        "type": ARG_TYPE.STR,
+        "description": "Custom API base URL for OpenAI-compatible endpoints.",
+        "required": False,
+        "label": "API base URL",
+    },
+)
diff --git a/mindsdb/integrations/handlers/ag2_handler/icon.svg b/mindsdb/integrations/handlers/ag2_handler/icon.svg
new file mode 100644
index 00000000000..a2cbe1d7425
--- /dev/null
+++ b/mindsdb/integrations/handlers/ag2_handler/icon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="90" height="50" fill="none"><path fill="#000001" d="M69.285 0h-3.232v3.232h3.232V0Zm-3.232 16.095h-3.21v6.442h3.21v-6.442Zm0-12.863h-3.21v3.21h3.21v-3.21Zm-3.21 9.652h-3.21v3.21h3.21v-3.21Zm0-6.442h-3.21v3.232h3.21V6.442Zm-3.211 3.232H53.19v3.21h6.442v-3.21ZM53.19 6.442H37.095v3.232H53.19V6.442Zm6.442 19.305v-6.42h-3.231v-3.232H33.885v3.232h-3.232v6.42h28.98Zm-9.652-6.42h3.21v3.21h-3.21v-3.21Zm-12.885 0h3.21v3.21h-3.21v-3.21Zm0-9.653h-6.442v3.21h6.442v-3.21Zm-6.442 3.21h-3.21v3.21h3.21v-3.21Zm0-6.442h-3.21v3.232h3.21V6.442Zm-3.211 9.653h-3.21v6.442h3.21v-6.442Zm0-12.863h-3.21v3.21h3.21v-3.21ZM24.232 0H21v3.232h3.232V0Z"/><path fill="#000" d="M65.867 37.748V34.33H55.615v-3.418h10.252v3.418h3.418v3.417h-3.418Zm-6.834 3.417v-3.417h6.834v3.417h-6.834ZM55.615 48v-6.835h3.418v3.418h10.252V48h-13.67Zm-13.89-13.67v-3.417h10.252v3.418H41.725Zm-3.417 10.253V34.33h3.417v10.252h-3.417Zm10.252 0v-3.418h-3.417v-3.417h6.834v6.835H48.56ZM41.725 48v-3.417h6.835V48h-6.835ZM21 48V34.33h3.417v-3.417h6.835v3.418h3.418V48h-3.418v-6.835h-6.835V48H21Zm3.417-10.252h6.835v-3.28h-6.835v3.28Z"/></svg>
diff --git a/mindsdb/integrations/handlers/ag2_handler/model_using_args.py b/mindsdb/integrations/handlers/ag2_handler/model_using_args.py
new file mode 100644
index 00000000000..24da7bcae0c
--- /dev/null
+++ b/mindsdb/integrations/handlers/ag2_handler/model_using_args.py
@@ -0,0 +1 @@
+model_using_args = {"openai_api_key": {"secret": True}}
diff --git a/mindsdb/integrations/handlers/ag2_handler/requirements.txt b/mindsdb/integrations/handlers/ag2_handler/requirements.txt
new file mode 100644
index 00000000000..39b5451ec17
--- /dev/null
+++ b/mindsdb/integrations/handlers/ag2_handler/requirements.txt
@@ -0,0 +1 @@
+ag2[openai]>=0.11.4,<1.0
diff --git a/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/__init__.py b/mindsdb/integrations/handlers/ag2_handler/tests/__init__.py
similarity index 100%
rename from mindsdb/integrations/utilities/rag/loaders/vector_store_loader/__init__.py
rename to mindsdb/integrations/handlers/ag2_handler/tests/__init__.py
diff --git a/mindsdb/integrations/handlers/ag2_handler/tests/test_ag2_handler.py b/mindsdb/integrations/handlers/ag2_handler/tests/test_ag2_handler.py
new file mode 100644
index 00000000000..9fa0e9e8c23
--- /dev/null
+++ b/mindsdb/integrations/handlers/ag2_handler/tests/test_ag2_handler.py
@@ -0,0 +1,230 @@
+"""Tests for the AG2 handler."""
+
+import json
+import unittest
+from unittest.mock import MagicMock, patch
+
+import pandas as pd
+
+from mindsdb.integrations.handlers.ag2_handler.ag2_handler import AG2Handler
+
+
+class TestAG2HandlerValidation(unittest.TestCase):
+    """Test AG2Handler validation methods."""
+
+    def test_create_validation_valid_agents(self):
+        args = {
+            "using": {
+                "agents": json.dumps(
+                    [
+                        {"name": "Agent1", "system_message": "You are agent 1."},
+                        {"name": "Agent2", "system_message": "You are agent 2."},
+                    ]
+                ),
+            }
+        }
+        # Should not raise
+        AG2Handler.create_validation("answer", args)
+
+    def test_create_validation_no_agents(self):
+        args = {"using": {}}
+        # Should not raise — agents are optional
+        AG2Handler.create_validation("answer", args)
+
+    def test_create_validation_invalid_agents_json(self):
+        args = {"using": {"agents": "not-valid-json"}}
+        with self.assertRaises(ValueError):
+            AG2Handler.create_validation("answer", args)
+
+    def test_create_validation_empty_agents_list(self):
+        args = {"using": {"agents": "[]"}}
+        with self.assertRaises(ValueError):
+            AG2Handler.create_validation("answer", args)
+
+    def test_create_validation_missing_agent_name(self):
+        args = {
+            "using": {
+                "agents": json.dumps([{"system_message": "No name here."}]),
+            }
+        }
+        with self.assertRaises(ValueError):
+            AG2Handler.create_validation("answer", args)
+
+    def test_create_validation_invalid_mode(self):
+        args = {"using": {"mode": "invalid"}}
+        with self.assertRaises(ValueError):
+            AG2Handler.create_validation("answer", args)
+
+    def test_create_validation_valid_modes(self):
+        for mode in ("single", "groupchat"):
+            args = {"using": {"mode": mode}}
+            AG2Handler.create_validation("answer", args)
+
+    def test_create_validation_invalid_speaker_selection(self):
+        args = {"using": {"speaker_selection": "invalid"}}
+        with self.assertRaises(ValueError):
+            AG2Handler.create_validation("answer", args)
+
+    def test_create_validation_valid_speaker_selections(self):
+        for sel in ("auto", "round_robin", "random"):
+            args = {"using": {"speaker_selection": sel}}
+            AG2Handler.create_validation("answer", args)
+
+
+class TestAG2HandlerCreate(unittest.TestCase):
+    """Test AG2Handler create method."""
+
+    def _make_handler(self):
+        handler = AG2Handler.__new__(AG2Handler)
+        handler.model_storage = MagicMock()
+        handler.engine_storage = MagicMock()
+        handler.engine_storage.get_connection_args.return_value = {
+            "openai_api_key": "test-key",
+            "model": "gpt-4o-mini",
+            "api_type": "openai",
+        }
+        return handler
+
+    def test_create_stores_args(self):
+        handler = self._make_handler()
+        args = {
+            "using": {
+                "agents": json.dumps([{"name": "Agent1"}]),
+                "max_rounds": 5,
+            }
+        }
+        handler.create("answer", args=args)
+        stored = handler.model_storage.json_set.call_args[0]
+        self.assertEqual(stored[0], "args")
+        self.assertEqual(stored[1]["target"], "answer")
+        self.assertEqual(stored[1]["max_rounds"], 5)
+
+    def test_create_stores_target(self):
+        handler = self._make_handler()
+        handler.create("my_output", args={"using": {}})
+        stored = handler.model_storage.json_set.call_args[0][1]
+        self.assertEqual(stored["target"], "my_output")
+
+
+class TestAG2HandlerPredict(unittest.TestCase):
+    """Test AG2Handler predict method."""
+
+    def _make_handler(self):
+        handler = AG2Handler.__new__(AG2Handler)
+        handler.model_storage = MagicMock()
+        handler.engine_storage = MagicMock()
+        handler.engine_storage.get_connection_args.return_value = {
+            "openai_api_key": "test-key",
+            "model": "gpt-4o-mini",
+            "api_type": "openai",
+        }
+        return handler
+
+    @patch.object(AG2Handler, "_run_agents")
+    def test_predict_calls_agents_per_row(self, mock_run):
+        mock_run.return_value = "Test answer"
+        handler = self._make_handler()
+        handler.model_storage.json_get.return_value = {
+            "agents": json.dumps([{"name": "Agent1"}]),
+            "max_rounds": 8,
+            "target": "answer",
+        }
+
+        df = pd.DataFrame({"question": ["Q1", "Q2"]})
+        result = handler.predict(df, args={})
+
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result["answer"][0], "Test answer")
+        self.assertEqual(result["answer"][1], "Test answer")
+        self.assertEqual(mock_run.call_count, 2)
+
+    @patch.object(AG2Handler, "_run_agents")
+    def test_predict_uses_target_column(self, mock_run):
+        mock_run.return_value = "Result"
+        handler = self._make_handler()
+        handler.model_storage.json_get.return_value = {
+            "target": "my_output",
+        }
+
+        df = pd.DataFrame({"question": ["Q1"]})
+        result = handler.predict(df, args={})
+
+        self.assertIn("my_output", result.columns)
+        self.assertEqual(result["my_output"][0], "Result")
+
+    @patch.object(AG2Handler, "_run_agents")
+    def test_predict_falls_back_to_first_column(self, mock_run):
+        mock_run.return_value = "Answer"
+        handler = self._make_handler()
+        handler.model_storage.json_get.return_value = {
+            "target": "answer",
+        }
+
+        df = pd.DataFrame({"prompt": ["Hello"]})
+        handler.predict(df, args={})
+
+        # Should use first column when 'question' is not present
+        call_kwargs = mock_run.call_args
+        self.assertEqual(call_kwargs[1]["question"], "Hello")
+
+    @patch.object(AG2Handler, "_run_agents")
+    def test_predict_handles_errors(self, mock_run):
+        mock_run.side_effect = RuntimeError("LLM failed")
+        handler = self._make_handler()
+        handler.model_storage.json_get.return_value = {
+            "target": "answer",
+        }
+
+        df = pd.DataFrame({"question": ["Q1"]})
+        result = handler.predict(df, args={})
+
+        self.assertIn("Error:", result["answer"][0])
+
+
+class TestAG2HandlerDescribe(unittest.TestCase):
+    """Test AG2Handler describe method."""
+
+    def _make_handler(self):
+        handler = AG2Handler.__new__(AG2Handler)
+        handler.model_storage = MagicMock()
+        handler.engine_storage = MagicMock()
+        return handler
+
+    def test_describe_default(self):
+        handler = self._make_handler()
+        handler.model_storage.json_get.return_value = {
+            "mode": "groupchat",
+            "max_rounds": 8,
+            "speaker_selection": "auto",
+            "agents": json.dumps([{"name": "A"}, {"name": "B"}]),
+        }
+        result = handler.describe()
+        self.assertEqual(result["num_agents"][0], 2)
+        self.assertEqual(result["mode"][0], "groupchat")
+
+    def test_describe_args(self):
+        handler = self._make_handler()
+        stored = {"mode": "single", "max_rounds": 5}
+        handler.model_storage.json_get.return_value = stored
+        result = handler.describe(attribute="args")
+        self.assertEqual(result["mode"][0], "single")
+
+    def test_describe_agents(self):
+        handler = self._make_handler()
+        agents = [{"name": "Researcher"}, {"name": "Writer"}]
+        handler.model_storage.json_get.return_value = {
+            "agents": json.dumps(agents),
+        }
+        result = handler.describe(attribute="agents")
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result["name"][0], "Researcher")
+
+    def test_describe_no_agents(self):
+        handler = self._make_handler()
+        handler.model_storage.json_get.return_value = {}
+        result = handler.describe(attribute="agents")
+        self.assertTrue(result.empty)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/mindsdb/integrations/handlers/bigcommerce_handler/__init__.py b/mindsdb/integrations/handlers/bigcommerce_handler/__init__.py
index 7e671a123a0..1117cbb3089 100644
--- a/mindsdb/integrations/handlers/bigcommerce_handler/__init__.py
+++ b/mindsdb/integrations/handlers/bigcommerce_handler/__init__.py
@@ -14,7 +14,7 @@
 title = "BigCommerce"
 name = "bigcommerce"
 type = HANDLER_TYPE.DATA
-icon_path = "bigcommerce-black.svg"
+icon_path = "icon.svg"
 support_level = HANDLER_SUPPORT_LEVEL.COMMUNITY
 
 __all__ = [
diff --git a/mindsdb/integrations/handlers/bigcommerce_handler/bigcommerce-black.svg b/mindsdb/integrations/handlers/bigcommerce_handler/icon.svg
similarity index 100%
rename from mindsdb/integrations/handlers/bigcommerce_handler/bigcommerce-black.svg
rename to mindsdb/integrations/handlers/bigcommerce_handler/icon.svg
diff --git a/mindsdb/integrations/handlers/bigquery_handler/bigquery_handler.py b/mindsdb/integrations/handlers/bigquery_handler/bigquery_handler.py
index 6e5cc215dad..7648a91c3fb 100644
--- a/mindsdb/integrations/handlers/bigquery_handler/bigquery_handler.py
+++ b/mindsdb/integrations/handlers/bigquery_handler/bigquery_handler.py
@@ -77,7 +77,8 @@ def connect(self):
         )
         credentials = google_sa_oauth2_manager.get_oauth2_credentials()
 
-        client = Client(project=self.connection_data["project_id"], credentials=credentials)
+        billing_project = self.connection_data.get("billing_project") or self.connection_data["project_id"]
+        client = Client(project=billing_project, credentials=credentials)
         self.is_connected = True
         self.connection = client
         return self.connection
@@ -105,7 +106,9 @@ def check_connection(self) -> StatusResponse:
             connection.query("SELECT 1;", timeout=10, retry=DEFAULT_RETRY.with_deadline(10))
 
             # Check if the dataset exists
-            connection.get_dataset(self.connection_data["dataset"])
+            dataset_project = self.connection_data.get("dataset_project") or self.connection_data["project_id"]
+            dataset_ref = f"{dataset_project}.{self.connection_data['dataset']}"
+            connection.get_dataset(dataset_ref)
 
             response.success = True
         except (BadRequest, ValueError) as e:
@@ -134,12 +137,12 @@ def native_query(self, query: str) -> Response:
         """
         connection = self.connect()
         try:
-            job_config = QueryJobConfig(
-                default_dataset=f"{self.connection_data['project_id']}.{self.connection_data['dataset']}"
-            )
+            dataset_project = self.connection_data.get("dataset_project") or self.connection_data["project_id"]
+            job_config = QueryJobConfig(default_dataset=f"{dataset_project}.{self.connection_data['dataset']}")
             query = connection.query(query, job_config=job_config)
             result = query.to_dataframe()
-            if not result.empty:
+            has_table_result = isinstance(result, pd.DataFrame) and (not result.empty or len(result.columns) > 0)
+            if has_table_result:
                 response = Response(RESPONSE_TYPE.TABLE, result)
             else:
                 response = Response(RESPONSE_TYPE.OK)
@@ -169,9 +172,10 @@ def get_tables(self) -> Response:
         Returns:
             Response: A response object containing the list of tables and views, formatted as per the `Response` class.
         """
+        dataset_project = self.connection_data.get("dataset_project") or self.connection_data["project_id"]
         query = f"""
             SELECT table_name, table_schema, table_type
-            FROM `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.TABLES`
+            FROM `{dataset_project}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.TABLES`
             WHERE table_type IN ('BASE TABLE', 'VIEW')
         """
         result = self.native_query(query)
@@ -189,9 +193,10 @@ def get_columns(self, table_name) -> Response:
         Raises:
             ValueError: If the 'table_name' is not a valid string.
         """
+        dataset_project = self.connection_data.get("dataset_project") or self.connection_data["project_id"]
         query = f"""
             SELECT column_name AS Field, data_type as Type
-            FROM `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.COLUMNS`
+            FROM `{dataset_project}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.COLUMNS`
             WHERE table_name = '{table_name}'
         """
         result = self.native_query(query)
@@ -207,19 +212,20 @@ def meta_get_tables(self, table_names: Optional[list] = None) -> Response:
         Returns:
             Response: A response object containing the metadata information, formatted as per the `Response` class.
         """
+        dataset_project = self.connection_data.get("dataset_project") or self.connection_data["project_id"]
         query = f"""
             SELECT
                 t.table_name,
                 t.table_schema,
                 t.table_type,
                 st.row_count
-            FROM 
-                `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.TABLES` AS t
-            JOIN 
-                `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.__TABLES__` AS st
-            ON 
+            FROM
+                `{dataset_project}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.TABLES` AS t
+            LEFT JOIN
+                `{dataset_project}.{self.connection_data["dataset"]}.__TABLES__` AS st
+            ON
                 t.table_name = st.table_id
-            WHERE 
+            WHERE
                 t.table_type IN ('BASE TABLE', 'VIEW')
         """
 
@@ -240,6 +246,7 @@ def meta_get_columns(self, table_names: Optional[list] = None) -> Response:
         Returns:
             Response: A response object containing the column metadata.
         """
+        dataset_project = self.connection_data.get("dataset_project") or self.connection_data["project_id"]
         query = f"""
             SELECT 
                 table_name,
@@ -251,7 +258,7 @@ def meta_get_columns(self, table_names: Optional[list] = None) -> Response:
                     ELSE FALSE
                 END AS is_nullable
             FROM 
-                `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.COLUMNS`
+                `{dataset_project}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.COLUMNS`
         """
 
         if table_names is not None and len(table_names) > 0:
@@ -273,9 +280,10 @@ def meta_get_column_statistics_for_table(self, table_name: str, columns: list) -
             Response: A response object containing the column statistics.
         """
         # Check column data types
+        dataset_project = self.connection_data.get("dataset_project") or self.connection_data["project_id"]
         column_types_query = f"""
             SELECT column_name, data_type
-            FROM `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.COLUMNS`
+            FROM `{dataset_project}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.COLUMNS`
             WHERE table_name = '{table_name}'
         """
         column_types_result = self.native_query(column_types_query)
@@ -335,7 +343,7 @@ def chunked(lst, n):
                             CAST(MAX(`{column}`) AS STRING) AS maximum_value,
                             COUNT(DISTINCT `{column}`) AS distinct_values_count
                         FROM
-                            `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.{table_name}`
+                            `{dataset_project}.{self.connection_data["dataset"]}.{table_name}`
                         """
                     )
                 else:
@@ -351,7 +359,7 @@ def chunked(lst, n):
                             CAST(NULL AS STRING) AS maximum_value,
                             CAST(NULL AS INT64) AS distinct_values_count
                         FROM
-                            `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.{table_name}`
+                            `{dataset_project}.{self.connection_data["dataset"]}.{table_name}`
                         """
                     )
 
@@ -391,16 +399,17 @@ def meta_get_primary_keys(self, table_names: Optional[list] = None) -> Response:
         Returns:
             Response: A response object containing the primary key information.
         """
+        dataset_project = self.connection_data.get("dataset_project") or self.connection_data["project_id"]
         query = f"""
             SELECT
                 tc.table_name,
                 kcu.column_name,
                 kcu.ordinal_position,
-                tc.constraint_name,
+                tc.constraint_name
             FROM
-                `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS` AS tc
+                `{dataset_project}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS` AS tc
             JOIN
-                `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE` AS kcu
+                `{dataset_project}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE` AS kcu
             ON
                 tc.constraint_name = kcu.constraint_name
             WHERE
@@ -424,6 +433,7 @@ def meta_get_foreign_keys(self, table_names: Optional[list] = None) -> Response:
         Returns:
             Response: A response object containing the foreign key information.
         """
+        dataset_project = self.connection_data.get("dataset_project") or self.connection_data["project_id"]
         query = f"""
             SELECT
                 ccu.table_name AS parent_table_name,
@@ -432,13 +442,13 @@ def meta_get_foreign_keys(self, table_names: Optional[list] = None) -> Response:
                 kcu.column_name AS child_column_name,
                 tc.constraint_name
             FROM
-                `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS` AS tc
+                `{dataset_project}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS` AS tc
             JOIN
-                `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE` AS kcu
+                `{dataset_project}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE` AS kcu
             ON
                 tc.constraint_name = kcu.constraint_name
             JOIN
-                `{self.connection_data["project_id"]}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE` AS ccu
+                `{dataset_project}.{self.connection_data["dataset"]}.INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE` AS ccu
             ON
                 tc.constraint_name = ccu.constraint_name
             WHERE
diff --git a/mindsdb/integrations/handlers/bigquery_handler/connection_args.py b/mindsdb/integrations/handlers/bigquery_handler/connection_args.py
index 0b002ef72f6..b3b90b0f9ba 100644
--- a/mindsdb/integrations/handlers/bigquery_handler/connection_args.py
+++ b/mindsdb/integrations/handlers/bigquery_handler/connection_args.py
@@ -5,26 +5,23 @@
 
 connection_args = OrderedDict(
     project_id={
-        'type': ARG_TYPE.STR,
-        'description': 'The BigQuery project id.'
+        "type": ARG_TYPE.STR,
+        "description": "Default BigQuery project id (used for billing and dataset lookup if not overridden).",
     },
-    dataset={
-        'type': ARG_TYPE.STR,
-        'description': 'The BigQuery dataset name.'
+    billing_project={
+        "type": ARG_TYPE.STR,
+        "description": "BigQuery project id to bill query jobs to (defaults to project_id).",
     },
+    dataset_project={"type": ARG_TYPE.STR, "description": "Project id that owns the dataset (defaults to project_id)."},
+    dataset={"type": ARG_TYPE.STR, "description": "The BigQuery dataset name."},
     service_account_keys={
-        'type': ARG_TYPE.PATH,
-        'description': 'Full path or URL to the service account JSON file',
-        'secret': True
-    },
-    service_account_json={
-        'type': ARG_TYPE.DICT,
-        'description': 'Content of service account JSON file',
-        'secret': True
+        "type": ARG_TYPE.PATH,
+        "description": "Full path or URL to the service account JSON file",
+        "secret": True,
     },
+    service_account_json={"type": ARG_TYPE.DICT, "description": "Content of service account JSON file", "secret": True},
 )
 
 connection_args_example = OrderedDict(
-    project_id='tough-future-332513',
-    service_account_keys='/home/bigq/tough-future-332513.json'
+    project_id="tough-future-332513", service_account_keys="/home/bigq/tough-future-332513.json"
 )
diff --git a/mindsdb/integrations/handlers/chromadb_handler/__init__.py b/mindsdb/integrations/handlers/chromadb_handler/__init__.py
index 9c5a069c83f..05d30cf7c7b 100644
--- a/mindsdb/integrations/handlers/chromadb_handler/__init__.py
+++ b/mindsdb/integrations/handlers/chromadb_handler/__init__.py
@@ -3,8 +3,10 @@
 from .__about__ import __description__ as description
 from .__about__ import __version__ as version
 from .connection_args import connection_args, connection_args_example
+
 try:
     from .chromadb_handler import ChromaDBHandler as Handler
+
     import_error = None
 except Exception as e:
     Handler = None
diff --git a/mindsdb/integrations/handlers/chromadb_handler/chromadb_handler.py b/mindsdb/integrations/handlers/chromadb_handler/chromadb_handler.py
index 61a5b439d12..32d0e566b00 100644
--- a/mindsdb/integrations/handlers/chromadb_handler/chromadb_handler.py
+++ b/mindsdb/integrations/handlers/chromadb_handler/chromadb_handler.py
@@ -215,17 +215,22 @@ def select(
 
         include = ["metadatas", "documents", "embeddings"]
 
-        # check if embedding vector filter is present
-        vector_filter = (
-            []
-            if conditions is None
-            else [condition for condition in conditions if condition.column == TableField.EMBEDDINGS.value]
-        )
+        # Identify Search Intent
+        vector_filter = None
+        content_filter = None
 
-        if len(vector_filter) > 0:
-            vector_filter = vector_filter[0]
-        else:
-            vector_filter = None
+        if conditions is not None:
+            # Embeddings
+            v_filters = [c for c in conditions if c.column == TableField.EMBEDDINGS.value]
+            if v_filters:
+                vector_filter = v_filters[0]
+
+            # Semantic Search
+            c_filters = [c for c in conditions if c.column == TableField.CONTENT.value]
+            if c_filters:
+                content_filter = c_filters[0]
+
+        # ID Filtering
         ids_include = []
         ids_exclude = []
 
@@ -242,14 +247,26 @@ def select(
                 elif condition.op == FilterOperator.NOT_IN:
                     ids_exclude.extend(condition.value)
 
-        if vector_filter is not None:
-            # similarity search
+        # Trigger search if Vector OR Content is present
+        if vector_filter is not None or content_filter is not None:
+            # Similarity search
             query_payload = {
                 "where": filters,
-                "query_embeddings": vector_filter.value if vector_filter is not None else None,
                 "include": include + ["distances"],
             }
 
+            # Handle Vector Search
+            if vector_filter:
+                query_payload["query_embeddings"] = vector_filter.value
+
+            # Handle Text Search
+            if content_filter:
+                val = content_filter.value
+                if isinstance(val, list):
+                    query_payload["query_texts"] = val
+                else:
+                    query_payload["query_texts"] = [val]
+
             if limit is not None:
                 if len(ids_include) == 0 and len(ids_exclude) == 0:
                     query_payload["n_results"] = limit
@@ -265,7 +282,7 @@ def select(
             embeddings = result["embeddings"][0]
 
         else:
-            # general get query
+            # general get query (Exact Match)
             result = collection.get(
                 ids=ids_include or None,
                 where=filters,
@@ -279,7 +296,6 @@ def select(
             embeddings = result["embeddings"]
             distances = None
 
-        # project based on columns
         payload = {
             TableField.ID.value: ids,
             TableField.CONTENT.value: documents,
@@ -290,7 +306,7 @@ def select(
         if columns is not None:
             payload = {column: payload[column] for column in columns if column != TableField.DISTANCE.value}
 
-        # always include distance
+        # Include distance
         distance_filter = None
         distance_col = TableField.DISTANCE.value
         if distances is not None:
diff --git a/mindsdb/integrations/handlers/chromadb_handler/settings.py b/mindsdb/integrations/handlers/chromadb_handler/settings.py
index 2b669ed75a8..279c404384e 100644
--- a/mindsdb/integrations/handlers/chromadb_handler/settings.py
+++ b/mindsdb/integrations/handlers/chromadb_handler/settings.py
@@ -14,7 +14,7 @@ class ChromaHandlerConfig(BaseModel):
     host: str = None
     port: str = None
     password: str = None
-    distance: str = 'cosine'
+    distance: str = "cosine"
 
     class Config:
         extra = "forbid"
@@ -27,13 +27,9 @@ def check_param_typos(cls, values: Any) -> Any:
         expected_params = cls.model_fields.keys()
         for key in values.keys():
             if key not in expected_params:
-                close_matches = difflib.get_close_matches(
-                    key, expected_params, cutoff=0.4
-                )
+                close_matches = difflib.get_close_matches(key, expected_params, cutoff=0.4)
                 if close_matches:
-                    raise ValueError(
-                        f"Unexpected parameter '{key}'. Did you mean '{close_matches[0]}'?"
-                    )
+                    raise ValueError(f"Unexpected parameter '{key}'. Did you mean '{close_matches[0]}'?")
                 else:
                     raise ValueError(f"Unexpected parameter '{key}'.")
         return values
@@ -56,8 +52,7 @@ def check_config(cls, values: Any) -> Any:
 
         if persist_directory and (host or port):
             raise ValueError(
-                f"For {vector_store} handler - if persistence_folder is provided, "
-                f"host, port should not be provided."
+                f"For {vector_store} handler - if persistence_folder is provided, host, port should not be provided."
             )
 
         return values
diff --git a/mindsdb/integrations/handlers/chromadb_handler/tests/test_chromadb_handler.py b/mindsdb/integrations/handlers/chromadb_handler/tests/test_chromadb_handler.py
new file mode 100644
index 00000000000..d3e5d330d16
--- /dev/null
+++ b/mindsdb/integrations/handlers/chromadb_handler/tests/test_chromadb_handler.py
@@ -0,0 +1,83 @@
+import unittest
+from unittest.mock import Mock, patch
+import pandas as pd
+from mindsdb.integrations.handlers.chromadb_handler.chromadb_handler import (
+    ChromaDBHandler,
+    TableField,
+)
+
+
+class MockCondition:
+    def __init__(self, column, op, value):
+        self.column = column
+        self.op = op
+        self.value = value
+
+
+class TestChromaHandler(unittest.TestCase):
+    def setUp(self):
+        self.handler = ChromaDBHandler(name="test_chroma", connection_data={}, handler_storage=Mock())
+
+    # INSERT
+    @patch("mindsdb.integrations.handlers.chromadb_handler.chromadb_handler.ChromaDBHandler.connect")
+    def test_insert_calls_upsert(self, mock_connect):
+        mock_client = Mock()
+        mock_collection = Mock()
+        mock_client.get_or_create_collection.return_value = mock_collection
+        self.handler._client = mock_client
+        self.handler.is_connected = True
+
+        df = pd.DataFrame(
+            {
+                TableField.CONTENT.value: ["Cat Photo"],
+                TableField.EMBEDDINGS.value: [[0.9, 0.1, 0.1]],
+                TableField.ID.value: ["img_1"],
+                TableField.METADATA.value: [{"author": "Sriram"}],
+            }
+        )
+        self.handler.insert("my_gallery", df)
+
+        call_args = mock_collection.upsert.call_args[1]
+        self.assertEqual(call_args["embeddings"], [[0.9, 0.1, 0.1]])
+
+    # SELECT
+    @patch("mindsdb.integrations.handlers.chromadb_handler.chromadb_handler.ChromaDBHandler.disconnect")
+    @patch("mindsdb.integrations.handlers.chromadb_handler.chromadb_handler.ChromaDBHandler.connect")
+    def test_select_semantic_search(self, mock_connect, mock_disconnect):
+        # Mock System
+        mock_client = Mock()
+        mock_collection = Mock()
+        mock_client.get_collection.return_value = mock_collection
+
+        self.handler._client = mock_client
+        self.handler.is_connected = True
+
+        # Mock Return Data
+        mock_result = {
+            "ids": [["id1"]],
+            "documents": [["Dog"]],
+            "metadatas": [[{}]],
+            "embeddings": [[[0.1, 0.2]]],
+            "distances": [[0.5]],
+        }
+        mock_collection.query.return_value = mock_result
+        mock_collection.get.return_value = mock_result
+
+        conditions = [MockCondition(column=TableField.CONTENT.value, op="=", value="Dog")]
+
+        self.handler.select("my_gallery", conditions=conditions)
+
+        # Verification
+        if not mock_collection.query.called:
+            self.fail("CRITICAL: The handler used .get() (Exact Match) instead of .query() (Semantic Search)!")
+
+        call_args = mock_collection.query.call_args[1]
+
+        if "query_texts" not in call_args:
+            self.fail("CRITICAL: The handler called .query() but forgot 'query_texts'!")
+
+        self.assertEqual(call_args["query_texts"], ["Dog"])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/mindsdb/integrations/handlers/clickhouse_handler/clickhouse_handler.py b/mindsdb/integrations/handlers/clickhouse_handler/clickhouse_handler.py
index feda48c1323..28836020e73 100644
--- a/mindsdb/integrations/handlers/clickhouse_handler/clickhouse_handler.py
+++ b/mindsdb/integrations/handlers/clickhouse_handler/clickhouse_handler.py
@@ -1,4 +1,5 @@
 from urllib.parse import quote, urlencode
+from typing import Optional, List
 
 import pandas as pd
 from sqlalchemy import create_engine
@@ -8,7 +9,7 @@
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 
 from mindsdb.utilities import log
-from mindsdb.integrations.libs.base import DatabaseHandler
+from mindsdb.integrations.libs.base import MetaDatabaseHandler
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
@@ -18,7 +19,7 @@
 logger = log.getLogger(__name__)
 
 
-class ClickHouseHandler(DatabaseHandler):
+class ClickHouseHandler(MetaDatabaseHandler):
     """
     This handler handles connection and execution of the ClickHouse statements.
     """
@@ -32,6 +33,7 @@ def __init__(self, name, connection_data, **kwargs):
         self.renderer = SqlalchemyRender(ClickHouseDialect)
         self.is_connected = False
         self.protocol = connection_data.get("protocol", "native")
+        self._has_is_nullable_column = None  # Cache for version check
 
     def __del__(self):
         if self.is_connected is True:
@@ -165,3 +167,315 @@ def get_columns(self, table_name) -> Response:
         q = f"DESCRIBE {table_name}"
         result = self.native_query(q)
         return result
+
+    def _check_has_is_nullable_column(self) -> bool:
+        """
+        Checks if the is_nullable column exists in system.columns table.
+        This column was added in ClickHouse 23.x.
+
+        Returns:
+            bool: True if is_nullable column exists, False otherwise.
+        """
+        if self._has_is_nullable_column is not None:
+            return self._has_is_nullable_column
+
+        try:
+            check_query = """
+                SELECT name 
+                FROM system.columns 
+                WHERE database = 'system' 
+                    AND table = 'columns' 
+                    AND name = 'is_nullable'
+            """
+            result = self.native_query(check_query)
+            self._has_is_nullable_column = result.resp_type == RESPONSE_TYPE.TABLE and not result.data_frame.empty
+        except Exception as e:
+            logger.warning(f"Could not check for is_nullable column: {e}")
+            self._has_is_nullable_column = False
+
+        return self._has_is_nullable_column
+
+    def meta_get_tables(self, table_names: Optional[List[str]] = None) -> Response:
+        """
+        Retrieves metadata information about the tables in the ClickHouse database
+        to be stored in the data catalog.
+
+        Args:
+            table_names (list): A list of table names for which to retrieve metadata information.
+
+        Returns:
+            Response: A response object containing the metadata information.
+        """
+        database = self.connection_data["database"]
+
+        query = f"""
+            SELECT 
+                name as table_name,
+                database as table_schema,
+                engine as table_type,
+                comment as table_description,
+                total_rows as row_count
+            FROM system.tables
+            WHERE database = '{database}'
+        """
+
+        if table_names is not None and len(table_names) > 0:
+            quoted_names = [f"'{t}'" for t in table_names]
+            query += f" AND name IN ({','.join(quoted_names)})"
+
+        query += " ORDER BY name"
+
+        result = self.native_query(query)
+        return result
+
+    def meta_get_columns(self, table_names: Optional[List[str]] = None) -> Response:
+        """
+        Retrieves column metadata for the specified tables (or all tables if no list is provided).
+        This includes column comments that you can set in ClickHouse using:
+        ALTER TABLE table_name MODIFY COLUMN column_name Type COMMENT 'description'
+
+        Args:
+            table_names (list): A list of table names for which to retrieve column metadata.
+
+        Returns:
+            Response: A response object containing the column metadata.
+        """
+        database = self.connection_data["database"]
+
+        # Check if is_nullable column is available (ClickHouse 23.x+)
+        has_is_nullable = self._check_has_is_nullable_column()
+
+        # Build the SELECT clause based on available columns
+        select_clause = """
+                table as table_name,
+                name as column_name,
+                type as data_type,
+                comment as column_description,
+                default_expression as column_default"""
+
+        if has_is_nullable:
+            select_clause += """,
+                is_nullable as is_nullable"""
+
+        query = f"""
+            SELECT {select_clause}
+            FROM system.columns
+            WHERE database = '{database}'
+        """
+
+        if table_names is not None and len(table_names) > 0:
+            quoted_names = [f"'{t}'" for t in table_names]
+            query += f" AND table IN ({','.join(quoted_names)})"
+
+        query += " ORDER BY table, position"
+
+        result = self.native_query(query)
+        return result
+
+    def meta_get_column_statistics(self, table_names: Optional[List[str]] = None) -> Response:
+        """
+        Retrieves column statistics for the specified tables (or all tables if no list is provided).
+        Uses the base class implementation which calls meta_get_column_statistics_for_table for each table.
+
+        Args:
+            table_names (list): A list of table names for which to retrieve column statistics.
+
+        Returns:
+            Response: A response object containing the column statistics.
+        """
+        # Use the base class implementation that calls meta_get_column_statistics_for_table
+        return super().meta_get_column_statistics(table_names)
+
+    def meta_get_column_statistics_for_table(
+        self, table_name: str, column_names: Optional[List[str]] = None
+    ) -> Response:
+        """
+        Retrieves column statistics for a specific table.
+
+        Args:
+            table_name (str): The name of the table.
+            column_names (Optional[List[str]]): List of column names to retrieve statistics for.
+                                                  If None, statistics for all columns will be returned.
+        Returns:
+            Response: A response object containing the column statistics for the table.
+        """
+        database = self.connection_data["database"]
+
+        # Get the list of columns for this table
+        columns_query = f"""
+            SELECT name, type
+            FROM system.columns
+            WHERE database = '{database}' AND table = '{table_name}'
+        """
+
+        if column_names:
+            quoted_names = [f"'{c}'" for c in column_names]
+            columns_query += f" AND name IN ({','.join(quoted_names)})"
+
+        try:
+            columns_result = self.native_query(columns_query)
+
+            if columns_result.resp_type == RESPONSE_TYPE.ERROR or columns_result.data_frame.empty:
+                logger.warning(f"No columns found for table {table_name}")
+                return Response(RESPONSE_TYPE.TABLE, pd.DataFrame())
+
+            # Build statistics query - collect all stats in one query
+            select_parts = []
+            for _, row in columns_result.data_frame.iterrows():
+                col = row["name"]
+                # Use backticks to handle special characters in column names
+                select_parts.extend(
+                    [
+                        f"countIf(`{col}` IS NULL) AS nulls_{col}",
+                        f"uniq(`{col}`) AS distincts_{col}",
+                        f"toString(min(`{col}`)) AS min_{col}",
+                        f"toString(max(`{col}`)) AS max_{col}",
+                    ]
+                )
+
+            if not select_parts:
+                return Response(RESPONSE_TYPE.TABLE, pd.DataFrame())
+
+            # Build the query to get stats for all columns at once
+            stats_query = f"""
+                SELECT 
+                    count(*) AS total_rows,
+                    {", ".join(select_parts)}
+                FROM `{database}`.`{table_name}`
+            """
+
+            stats_result = self.native_query(stats_query)
+
+            if stats_result.resp_type != RESPONSE_TYPE.TABLE or stats_result.data_frame.empty:
+                logger.warning(f"Could not retrieve stats for table {table_name}")
+                # Return placeholder stats
+                placeholder_data = []
+                for _, row in columns_result.data_frame.iterrows():
+                    placeholder_data.append(
+                        {
+                            "table_name": table_name,
+                            "column_name": row["name"],
+                            "null_percentage": None,
+                            "distinct_values_count": None,
+                            "most_common_values": None,
+                            "most_common_frequencies": None,
+                            "minimum_value": None,
+                            "maximum_value": None,
+                        }
+                    )
+                return Response(RESPONSE_TYPE.TABLE, pd.DataFrame(placeholder_data))
+
+            # Parse the stats result
+            stats_data = stats_result.data_frame.iloc[0]
+            total_rows = stats_data.get("total_rows", 0)
+
+            # Build the final statistics DataFrame
+            all_stats = []
+            for _, row in columns_result.data_frame.iterrows():
+                col = row["name"]
+                nulls = stats_data.get(f"nulls_{col}", 0)
+                distincts = stats_data.get(f"distincts_{col}", None)
+                min_val = stats_data.get(f"min_{col}", None)
+                max_val = stats_data.get(f"max_{col}", None)
+
+                # Calculate null percentage
+                null_pct = None
+                if total_rows is not None and total_rows > 0:
+                    null_pct = round((nulls / total_rows) * 100, 2)
+
+                all_stats.append(
+                    {
+                        "table_name": table_name,
+                        "column_name": col,
+                        "null_percentage": null_pct,
+                        "distinct_values_count": distincts,
+                        "most_common_values": None,
+                        "most_common_frequencies": None,
+                        "minimum_value": min_val,
+                        "maximum_value": max_val,
+                    }
+                )
+
+            return Response(RESPONSE_TYPE.TABLE, pd.DataFrame(all_stats))
+
+        except Exception as e:
+            logger.error(f"Exception while fetching statistics for table {table_name}: {e}")
+            # Return empty stats on error
+            return Response(
+                RESPONSE_TYPE.ERROR, error_message=f"Could not retrieve statistics for table {table_name}: {str(e)}"
+            )
+
+    def meta_get_primary_keys(self, table_names: Optional[List[str]] = None) -> Response:
+        """
+        Retrieves primary key information for the specified tables (or all tables if no list is provided).
+
+        Args:
+            table_names (list): A list of table names for which to retrieve primary key information.
+
+        Returns:
+            Response: A response object containing the primary key information.
+        """
+        database = self.connection_data["database"]
+
+        query = f"""
+            SELECT 
+                table as table_name,
+                name as column_name,
+                position as ordinal_position,
+                'PRIMARY' as constraint_name
+            FROM system.columns
+            WHERE database = '{database}'
+                AND is_in_primary_key = 1
+        """
+
+        if table_names is not None and len(table_names) > 0:
+            quoted_names = [f"'{t}'" for t in table_names]
+            query += f" AND table IN ({','.join(quoted_names)})"
+
+        query += " ORDER BY table, position"
+
+        result = self.native_query(query)
+        return result
+
+    def meta_get_foreign_keys(self, table_names: Optional[List[str]] = None) -> Response:
+        """
+        Retrieves foreign key information for the specified tables (or all tables if no list is provided).
+        Note: ClickHouse does not enforce foreign key constraints, but this method is provided for completeness.
+
+        Args:
+            table_names (list): A list of table names for which to retrieve foreign key information.
+
+        Returns:
+            Response: A response object containing an empty DataFrame (ClickHouse doesn't support foreign keys).
+        """
+        # ClickHouse does not support foreign key constraints
+        # Return an empty DataFrame with the expected columns
+        df = pd.DataFrame(
+            columns=[
+                "parent_table_name",
+                "parent_column_name",
+                "child_table_name",
+                "child_column_name",
+                "constraint_name",
+            ]
+        )
+        return Response(RESPONSE_TYPE.TABLE, df)
+
+    def meta_get_handler_info(self, **kwargs) -> str:
+        """
+        Retrieves information about the ClickHouse handler design and implementation.
+
+        Returns:
+            str: A string containing information about the ClickHouse handler's capabilities.
+        """
+        return (
+            "ClickHouse is a fast open-source column-oriented database management system.\n"
+            "Key features:\n"
+            "- Supports standard SQL syntax with some extensions\n"
+            "- Use backticks (`) to quote table and column names with special characters\n"
+            "- Does NOT support traditional foreign key constraints (they are not enforced)\n"
+            "- Optimized for analytical queries (OLAP) rather than transactional operations (OLTP)\n"
+            "- Supports various table engines (MergeTree, ReplacingMergeTree, SummingMergeTree, etc.)\n"
+            "- All ClickHouse functions are case-sensitive\n"
+            "- Native support for arrays, nested structures, and approximate algorithms\n"
+        )
diff --git a/mindsdb/integrations/handlers/confluence_handler/confluence_api_client.py b/mindsdb/integrations/handlers/confluence_handler/confluence_api_client.py
index 2ce6dce173d..e6882a8dee1 100644
--- a/mindsdb/integrations/handlers/confluence_handler/confluence_api_client.py
+++ b/mindsdb/integrations/handlers/confluence_handler/confluence_api_client.py
@@ -1,17 +1,37 @@
-from typing import List
+from typing import List, Optional
 
 import requests
 
 
 class ConfluenceAPIClient:
-    def __init__(self, url: str, username: str, password: str):
-        self.url = url
+    def __init__(
+        self,
+        url: str,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        token: Optional[str] = None,
+        auth_method: Optional[str] = None,
+        is_selfHosted: bool = False,
+    ):
+        self.url = url.rstrip("/")
         self.username = username
         self.password = password
+        self.token = token
+        self.auth_method = auth_method
+        self.is_selfHosted = is_selfHosted
         self.session = requests.Session()
-        self.session.auth = (self.username, self.password)
         self.session.headers.update({"Accept": "application/json"})
 
+        use_bearer = (auth_method == "bearer") or bool(token)
+        if use_bearer:
+            if not token:
+                raise ValueError("Token must be provided for bearer authentication.")
+            self.session.headers.update({"Authorization": f"Bearer {token}"})
+        else:
+            if not username or not password:
+                raise ValueError("Username and password must be provided for basic authentication.")
+            self.session.auth = (username, password)
+
     def get_spaces(
         self,
         ids: List[int] = None,
@@ -20,6 +40,19 @@ def get_spaces(
         status: str = None,
         sort_condition: str = None,
         limit: int = None,
+    ):
+        if self.is_selfHosted:
+            return self._get_spaces_server(ids, keys, space_type, status, limit)
+        return self._get_spaces_cloud(ids, keys, space_type, status, sort_condition, limit)
+
+    def _get_spaces_cloud(
+        self,
+        ids: List[int] = None,
+        keys: List[str] = None,
+        space_type: str = None,
+        status: str = None,
+        sort_condition: str = None,
+        limit: int = None,
     ):
         url = f"{self.url}/wiki/api/v2/spaces"
         params = {
@@ -40,6 +73,63 @@ def get_spaces(
 
         return self._paginate(url, params)
 
+    def _get_spaces_server(
+        self,
+        ids: List[int] = None,
+        keys: List[str] = None,
+        space_type: str = None,
+        status: str = None,
+        limit: int = None,
+    ):
+        """Fetch spaces via Confluence Server REST API v1."""
+        url = f"{self.url}/rest/api/space"
+        # expand=description.view to get the description body;
+        # expand=homepage to get the homepage page ID.
+        params = {
+            "expand": "description.view,homepage",
+        }
+        if ids:
+            params["spaceId"] = ids
+        if keys:
+            params["spaceKey"] = keys
+        if space_type:
+            params["type"] = space_type
+        if status:
+            params["status"] = status
+        if limit:
+            params["limit"] = limit
+
+        results = self._paginate(url, params)
+        return [self._normalize_v1_space(s) for s in results]
+
+    def _normalize_v1_space(self, space: dict) -> dict:
+        """Normalize a Confluence Server v1 space response to match the Cloud v2 shape."""
+        description_view = space.get("description", {}).get("view", {})
+        homepage = space.get("homepage", {})
+
+        return {
+            "id": space.get("id"),
+            "key": space.get("key"),
+            "name": space.get("name"),
+            "type": space.get("type"),
+            "description": {
+                "view": {
+                    "representation": description_view.get("representation"),
+                    "value": description_view.get("value"),
+                }
+            },
+            "status": space.get("status"),
+            # Cloud-only fields: set to None so pd.json_normalize produces the
+            # expected columns and the DataFrame projection doesn't crash.
+            "authorId": None,
+            "createdAt": None,
+            "homepageId": homepage.get("id"),
+            "currentActiveAlias": None,
+            "_links": {
+                "webui": space.get("_links", {}).get("webui"),
+            },
+        }
+
     def get_pages(
         self,
         page_ids: List[int] = None,
@@ -48,6 +138,19 @@ def get_pages(
         title: str = None,
         sort_condition: str = None,
         limit: int = None,
+    ) -> List[dict]:
+        if self.is_selfHosted:
+            return self._get_pages_server(page_ids, space_ids, statuses, title, limit)
+        return self._get_pages_cloud(page_ids, space_ids, statuses, title, sort_condition, limit)
+
+    def _get_pages_cloud(
+        self,
+        page_ids: List[int] = None,
+        space_ids: List[int] = None,
+        statuses: List[str] = None,
+        title: str = None,
+        sort_condition: str = None,
+        limit: int = None,
     ) -> List[dict]:
         url = f"{self.url}/wiki/api/v2/pages"
         params = {
@@ -68,6 +171,76 @@ def get_pages(
 
         return self._paginate(url, params)
 
+    def _get_pages_server(
+        self,
+        page_ids: List[int] = None,
+        space_ids: List[int] = None,
+        statuses: List[str] = None,
+        title: str = None,
+        limit: int = None,
+    ) -> List[dict]:
+        """Fetch pages via Confluence Server REST API v1 using CQL search."""
+        cql_parts = ["type=page"]
+        if page_ids:
+            id_cql = " OR ".join([f"id={pid}" for pid in page_ids])
+            cql_parts.append(f"({id_cql})")
+        if space_ids:
+            space_cql = " OR ".join([f"space.id={sid}" for sid in space_ids])
+            cql_parts.append(f"({space_cql})")
+        if statuses:
+            status_cql = " OR ".join([f'status="{s}"' for s in statuses])
+            cql_parts.append(f"({status_cql})")
+        if title:
+            escaped_title = title.replace('"', '\\"')
+            cql_parts.append(f'title="{escaped_title}"')
+
+        url = f"{self.url}/rest/api/content/search"
+        params = {
+            "cql": " AND ".join(cql_parts),
+            "expand": "body.storage,version,space,history,ancestors",
+        }
+        if limit:
+            params["limit"] = limit
+
+        results = self._paginate(url, params)
+        return [self._normalize_v1_page(p) for p in results]
+
+    def _normalize_v1_page(self, page: dict) -> dict:
+        """Normalize a Confluence Server v1 page response to match the Cloud v2 shape."""
+        ancestors = page.get("ancestors", [])
+        parent = ancestors[-1] if ancestors else {}
+        history = page.get("history", {})
+        created_by = history.get("createdBy", {})
+        version = page.get("version", {})
+        version_by = version.get("by", {})
+
+        return {
+            "id": page.get("id"),
+            "status": page.get("status"),
+            "title": page.get("title"),
+            "spaceId": page.get("space", {}).get("id"),
+            "parentId": parent.get("id"),
+            "parentType": parent.get("type"),
+            "position": None,
+            "authorId": created_by.get("accountId") or created_by.get("username"),
+            "ownerId": created_by.get("accountId") or created_by.get("username"),
+            "lastOwnerId": None,
+            "createdAt": history.get("createdDate"),
+            "version": {
+                "createdAt": version.get("when"),
+                "message": version.get("message", ""),
+                "number": version.get("number"),
+                "minorEdit": version.get("minorEdit", False),
+                "authorId": version_by.get("accountId") or version_by.get("username"),
+            },
+            "body": page.get("body", {}),
+            "_links": {
+                "webui": page.get("_links", {}).get("webui"),
+                "editui": page.get("_links", {}).get("editui"),
+                "tinyui": page.get("_links", {}).get("tinyui"),
+            },
+        }
+
     def get_blogposts(
         self,
         post_ids: List[int] = None,
@@ -76,6 +249,19 @@ def get_blogposts(
         title: str = None,
         sort_condition: str = None,
         limit: int = None,
+    ) -> List[dict]:
+        if self.is_selfHosted:
+            return self._get_blogposts_server(post_ids, space_ids, statuses, title, limit)
+        return self._get_blogposts_cloud(post_ids, space_ids, statuses, title, sort_condition, limit)
+
+    def _get_blogposts_cloud(
+        self,
+        post_ids: List[int] = None,
+        space_ids: List[str] = None,
+        statuses: List[str] = None,
+        title: str = None,
+        sort_condition: str = None,
+        limit: int = None,
     ) -> List[dict]:
         url = f"{self.url}/wiki/api/v2/blogposts"
         params = {
@@ -96,12 +282,79 @@ def get_blogposts(
 
         return self._paginate(url, params)
 
+    def _get_blogposts_server(
+        self,
+        post_ids: List[int] = None,
+        space_ids: List[str] = None,
+        statuses: List[str] = None,
+        title: str = None,
+        limit: int = None,
+    ) -> List[dict]:
+        """Fetch blog posts via Confluence Server REST API v1 using CQL search."""
+        cql_parts = ["type=blogpost"]
+        if post_ids:
+            id_cql = " OR ".join([f"id={pid}" for pid in post_ids])
+            cql_parts.append(f"({id_cql})")
+        if space_ids:
+            space_cql = " OR ".join([f"space.id={sid}" for sid in space_ids])
+            cql_parts.append(f"({space_cql})")
+        if statuses:
+            status_cql = " OR ".join([f'status="{s}"' for s in statuses])
+            cql_parts.append(f"({status_cql})")
+        if title:
+            escaped_title = title.replace('"', '\\"')
+            cql_parts.append(f'title="{escaped_title}"')
+
+        url = f"{self.url}/rest/api/content/search"
+        params = {
+            "cql": " AND ".join(cql_parts),
+            "expand": "body.storage,version,space,history",
+        }
+        if limit:
+            params["limit"] = limit
+
+        results = self._paginate(url, params)
+        return [self._normalize_v1_blogpost(p) for p in results]
+
+    def _normalize_v1_blogpost(self, post: dict) -> dict:
+        """Normalize a Confluence Server v1 blogpost response to match the Cloud v2 shape."""
+        history = post.get("history", {})
+        created_by = history.get("createdBy", {})
+        version = post.get("version", {})
+        version_by = version.get("by", {})
+
+        return {
+            "id": post.get("id"),
+            "status": post.get("status"),
+            "title": post.get("title"),
+            "spaceId": post.get("space", {}).get("id"),
+            "authorId": created_by.get("accountId") or created_by.get("username"),
+            "createdAt": history.get("createdDate"),
+            "version": {
+                "createdAt": version.get("when"),
+                "message": version.get("message", ""),
+                "number": version.get("number"),
+                "minorEdit": version.get("minorEdit", False),
+                "authorId": version_by.get("accountId") or version_by.get("username"),
+            },
+            "body": post.get("body", {}),
+            "_links": {
+                "webui": post.get("_links", {}).get("webui"),
+                "editui": post.get("_links", {}).get("editui"),
+                "tinyui": post.get("_links", {}).get("tinyui"),
+            },
+        }
+
     def get_whiteboard_by_id(self, whiteboard_id: int) -> dict:
+        if self.is_selfHosted:
+            raise NotImplementedError("Whiteboards are only available on Confluence Cloud.")
         url = f"{self.url}/wiki/api/v2/whiteboards/{whiteboard_id}"
 
         return self._make_request("GET", url)
 
     def get_database_by_id(self, database_id: int) -> dict:
+        if self.is_selfHosted:
+            raise NotImplementedError("Databases are only available on Confluence Cloud.")
         url = f"{self.url}/wiki/api/v2/databases/{database_id}"
 
         return self._make_request("GET", url)
@@ -118,6 +371,11 @@ def get_tasks(
         status: str = None,
         limit: int = None,
     ) -> List[dict]:
+        if self.is_selfHosted:
+            raise NotImplementedError(
+                "The tasks endpoint is only available on Confluence Cloud. "
+                "Confluence Server/Data Center does not expose a dedicated REST API for inline tasks."
+            )
         url = f"{self.url}/wiki/api/v2/tasks"
         params = {
             "body-format": "storage",
@@ -148,20 +406,29 @@ def _paginate(self, url: str, params: dict = None) -> List[dict]:
         response = self._make_request("GET", url, params)
         results.extend(response["results"])
 
-        while response["_links"].get("next"):
-            next_url = response["_links"].get("next")
-            next_params = {}
-            if params:
-                next_params.update(params)
-            if "cursor=" in next_url:
-                # cursor= is 7 characters long
-                cursor_start = next_url.find("cursor=") + 7
-                cursor_value = next_url[cursor_start:]
+        while response.get("_links", {}).get("next"):
+            next_path = response["_links"]["next"]
+            if "cursor=" in next_path:
+                # Cloud v2 cursor-based pagination: reconstruct request against the
+                # original URL with the cursor value appended as a query param.
+                next_params = {}
+                if params:
+                    next_params.update(params)
+                cursor_start = next_path.find("cursor=") + 7
+                cursor_value = next_path[cursor_start:]
                 if "&" in cursor_value:
                     cursor_value = cursor_value.split("&")[0]
                 next_params["cursor"] = cursor_value
                 response = self._make_request("GET", url, next_params)
             else:
+                # Offset-based pagination (Cloud v1 / Server): next_path may be
+                # relative (e.g. "/rest/api/space?start=25&limit=25").  Reconstruct
+                # the absolute URL using _links.base when present.
+                if next_path.startswith("http"):
+                    next_url = next_path
+                else:
+                    base = response["_links"].get("base", self.url)
+                    next_url = base.rstrip("/") + next_path
                 response = self._make_request("GET", next_url)
             results.extend(response["results"])
 
diff --git a/mindsdb/integrations/handlers/confluence_handler/confluence_handler.py b/mindsdb/integrations/handlers/confluence_handler/confluence_handler.py
index d1af184b9a5..054bf36cc41 100644
--- a/mindsdb/integrations/handlers/confluence_handler/confluence_handler.py
+++ b/mindsdb/integrations/handlers/confluence_handler/confluence_handler.py
@@ -58,24 +58,48 @@ def connect(self) -> ConfluenceAPIClient:
             ValueError: If the required connection parameters are not provided.
 
         Returns:
-            atlassian.confluence.Confluence: A connection object to the Confluence API.
+            ConfluenceAPIClient: A connection object to the Confluence API.
         """
         if self.is_connected is True:
             return self.connection
 
-        if not all(
-            key in self.connection_data and self.connection_data.get(key)
-            for key in ["api_base", "username", "password"]
-        ):
-            raise ValueError(
-                "Required parameters (api_base, username, password) must be provided and should not be empty."
+        api_base = self.connection_data.get("api_base")
+        username = self.connection_data.get("username")
+        password = self.connection_data.get("password")
+        token = self.connection_data.get("token")
+        auth_method = self.connection_data.get("auth_method")
+
+        is_selfHosted = self.connection_data.get("is_selfHosted")
+        if is_selfHosted is None and "is_cloud" in self.connection_data:
+            is_selfHosted = not self.connection_data.get("is_cloud", True)
+        if is_selfHosted is None:
+            is_selfHosted = False
+
+        if not api_base:
+            raise ValueError("Required parameter 'api_base' must be provided and should not be empty.")
+
+        if token or auth_method == "bearer":
+            if not token:
+                raise ValueError("Required parameter 'token' must be provided for bearer authentication.")
+
+            self.connection = ConfluenceAPIClient(
+                url=api_base,
+                token=token,
+                auth_method="bearer",
+                is_selfHosted=is_selfHosted,
+            )
+        else:
+            if not username or not password:
+                raise ValueError(
+                    "Required parameters for basic auth (api_base, username, password) must be provided and should not be empty."
+                )
+
+            self.connection = ConfluenceAPIClient(
+                url=api_base,
+                username=username,
+                password=password,
+                is_selfHosted=is_selfHosted,
             )
-
-        self.connection = ConfluenceAPIClient(
-            url=self.connection_data.get("api_base"),
-            username=self.connection_data.get("username"),
-            password=self.connection_data.get("password"),
-        )
 
         self.is_connected = True
         return self.connection
diff --git a/mindsdb/integrations/handlers/confluence_handler/connection_args.py b/mindsdb/integrations/handlers/confluence_handler/connection_args.py
index 52734cda9bf..7c50ec57880 100644
--- a/mindsdb/integrations/handlers/confluence_handler/connection_args.py
+++ b/mindsdb/integrations/handlers/confluence_handler/connection_args.py
@@ -1,32 +1,51 @@
 from collections import OrderedDict
-
 from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
 
-
 connection_args = OrderedDict(
     api_base={
         "type": ARG_TYPE.URL,
         "description": "The base URL of the Confluence instance/server.",
         "label": "Base URL",
-        "required": True
+        "required": True,
     },
     username={
         "type": ARG_TYPE.STR,
-        "description": "The username for the Confluence account.",
+        "description": "The username for basic authentication.",
         "label": "Username",
-        "required": True
+        "required": False,
     },
     password={
         "type": ARG_TYPE.STR,
-        "description": "The API token for the Confluence account.",
+        "description": "The password or API token for basic authentication.",
         "label": "Password",
-        "required": True,
-        "secret": True
-    }
+        "required": False,
+        "secret": True,
+    },
+    token={
+        "type": ARG_TYPE.STR,
+        "description": "The personal access token for bearer authentication.",
+        "label": "Token",
+        "required": False,
+        "secret": True,
+    },
+    auth_method={
+        "type": ARG_TYPE.STR,
+        "description": "Authentication method to use. Supported values: 'basic', 'bearer'.",
+        "label": "Auth Method",
+        "required": False,
+    },
+    is_selfHosted={
+        "type": ARG_TYPE.BOOL,
+        "description": (
+            "Set to True for Confluence Server / Data Center (on-premises), or False (default) for Confluence Cloud. "
+            "When True, the handler uses the Confluence Server REST API v1. "
+            "Note: 'whiteboards', 'databases', and 'tasks' tables are Cloud-only and will raise an error when self-hosted mode is enabled."
+        ),
+        "label": "Is Self Hosted",
+        "required": False,
+    },
 )
 
 connection_args_example = OrderedDict(
-    api_base="https://marios.atlassian.net/",
-    username="your_username",
-    password="access_token"
+    api_base="https://marios.atlassian.net/", token="your_personal_access_token", auth_method="bearer"
 )
diff --git a/mindsdb/integrations/handlers/databricks_handler/databricks_handler.py b/mindsdb/integrations/handlers/databricks_handler/databricks_handler.py
index 2feab0a37d4..755308d419b 100644
--- a/mindsdb/integrations/handlers/databricks_handler/databricks_handler.py
+++ b/mindsdb/integrations/handlers/databricks_handler/databricks_handler.py
@@ -404,7 +404,7 @@ def native_query(self, query: Text) -> Response:
             try:
                 cursor.execute(query)
                 result = cursor.fetchall()
-                if result:
+                if cursor.description:
                     response = Response(
                         RESPONSE_TYPE.TABLE,
                         data_frame=pd.DataFrame(result, columns=[x[0] for x in cursor.description]),
@@ -465,6 +465,8 @@ def get_tables(self, all: bool = False) -> Response:
                 {all_filter}
         """
         result = self.native_query(query)
+        if result.resp_type != RESPONSE_TYPE.TABLE or result.data_frame is None:
+            return result
         df = result.data_frame
         result.data_frame = df.rename(columns={col: col.upper() for col in df.columns})
         return result
diff --git a/mindsdb/integrations/handlers/databricks_handler/requirements.txt b/mindsdb/integrations/handlers/databricks_handler/requirements.txt
index 212e52860fc..0137133cc54 100644
--- a/mindsdb/integrations/handlers/databricks_handler/requirements.txt
+++ b/mindsdb/integrations/handlers/databricks_handler/requirements.txt
@@ -1 +1 @@
-databricks-sql-connector >= 3.7.1, < 4.0.0
+databricks-sql-connector==4.2.3
diff --git a/mindsdb/integrations/handlers/denodo_handler/README.md b/mindsdb/integrations/handlers/denodo_handler/README.md
new file mode 100644
index 00000000000..87dcf6b3eda
--- /dev/null
+++ b/mindsdb/integrations/handlers/denodo_handler/README.md
@@ -0,0 +1,57 @@
+---
+title: Denodo
+sidebarTitle: Denodo
+---
+
+This documentation describes the integration of MindsDB with [Denodo](https://www.denodo.com/), a powerful data virtualization platform that enables real-time access and integration of multiple data sources.
+The integration allows MindsDB to query Denodo views and enhance them with AI capabilities.
+
+## Prerequisites
+
+Before proceeding, ensure the following prerequisites are met:
+
+1. Install MindsDB locally via [Docker](https://docs.mindsdb.com/setup/self-hosted/docker) or [Docker Desktop](https://docs.mindsdb.com/setup/self-hosted/docker-desktop).
+
+## Connection
+
+Establish a connection to Denodo from MindsDB by executing the following SQL command and providing its [handler name](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/denodo_handler) as an engine.
+
+```sql
+CREATE DATABASE denodo_conn
+WITH ENGINE = 'denodo',
+PARAMETERS = {
+    "host": "host-name",
+    "port": 9996,
+    "database": "db-name",
+    "user": "user-name",
+    "password": "password"
+};
+```
+
+Required connection parameters include the following:
+
+- `user`: The username for the Denodo database.
+- `password`: The password for the Denodo database.
+- `host`: The hostname, IP address, or URL of the Denodo server.
+- `port`: The port number for connecting to the Denodo server (default is `9999`).
+- `database`: The name of the Denodo virtual database to connect to.
+
+## Usage
+
+The following usage examples utilize the connection to Denodo made via the `CREATE DATABASE` statement and named `denodo_conn`.
+
+Retrieve data from a specified Denodo view by providing the integration and view name.
+
+```sql
+SELECT *
+FROM denodo_conn.view_name
+LIMIT 10;
+```
+
+Running native SQL queries on Denodo views is also supported.
+
+```sql
+SELECT * FROM denodno_conn (
+    DESC VIEW view_name
+);
+```
\ No newline at end of file
diff --git a/mindsdb/integrations/handlers/denodo_handler/__about__.py b/mindsdb/integrations/handlers/denodo_handler/__about__.py
new file mode 100644
index 00000000000..c780673cdff
--- /dev/null
+++ b/mindsdb/integrations/handlers/denodo_handler/__about__.py
@@ -0,0 +1,9 @@
+__title__ = "MindsDB Denodo handler"
+__package_name__ = "mindsdb_denodo_handler"
+__version__ = "0.0.1"
+__description__ = "MindsDB handler for Denodo"
+__author__ = "Ritwick Raj Makhal"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2022- mindsdb"
diff --git a/mindsdb/integrations/handlers/denodo_handler/__init__.py b/mindsdb/integrations/handlers/denodo_handler/__init__.py
new file mode 100644
index 00000000000..20293b54d55
--- /dev/null
+++ b/mindsdb/integrations/handlers/denodo_handler/__init__.py
@@ -0,0 +1,30 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+from .connection_args import connection_args, connection_args_example
+
+try:
+    from .denodo_handler import DenodoHandler as Handler
+
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Denodo"
+name = "denodo"
+type = HANDLER_TYPE.DATA
+icon_path = "icon.png"
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "connection_args",
+    "connection_args_example",
+    "import_error",
+    "icon_path",
+]
diff --git a/mindsdb/integrations/handlers/denodo_handler/connection_args.py b/mindsdb/integrations/handlers/denodo_handler/connection_args.py
new file mode 100644
index 00000000000..384bfa677c7
--- /dev/null
+++ b/mindsdb/integrations/handlers/denodo_handler/connection_args.py
@@ -0,0 +1,46 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+connection_args = OrderedDict(
+    user={
+        "type": ARG_TYPE.STR,
+        "description": "The user name used to authenticate with the Denodo server.",
+        "required": True,
+        "label": "User",
+    },
+    password={
+        "type": ARG_TYPE.PWD,
+        "description": "The password to authenticate the user with the Denodo server.",
+        "required": True,
+        "label": "Password",
+        "secret": True,
+    },
+    database={
+        "type": ARG_TYPE.STR,
+        "description": "The database name to use when connecting with the Denodo server.",
+        "required": True,
+        "label": "Database",
+    },
+    host={
+        "type": ARG_TYPE.STR,
+        "description": "The host name or IP address of the Denodo server.",
+        "required": True,
+        "label": "Host",
+    },
+    port={
+        "type": ARG_TYPE.INT,
+        "description": "The TCP/IP port of the Denodo server. Must be an integer.",
+        "required": True,
+        "label": "Port",
+    },
+)
+
+connection_args_example = {
+    "host": "localhost",
+    "port": 9996,
+    "user": "admin",
+    "password": "password",
+    "database": "database",
+}
diff --git a/mindsdb/integrations/handlers/denodo_handler/denodo_handler.py b/mindsdb/integrations/handlers/denodo_handler/denodo_handler.py
new file mode 100644
index 00000000000..14af2d18372
--- /dev/null
+++ b/mindsdb/integrations/handlers/denodo_handler/denodo_handler.py
@@ -0,0 +1,153 @@
+import pandas as pd
+from typing import Optional
+import psycopg2 as dbdriver
+from psycopg2 import OperationalError, InterfaceError, ProgrammingError
+
+from mindsdb_sql_parser import parse_sql
+from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb_sql_parser.ast.base import ASTNode
+
+from mindsdb.utilities import log
+from mindsdb.integrations.libs.base import DatabaseHandler
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+    HandlerResponse as Response,
+    RESPONSE_TYPE,
+)
+
+logger = log.getLogger(__name__)
+
+
+class DenodoHandler(DatabaseHandler):
+    """
+    This handler handles connection and execution of the Denodo statements.
+    """
+
+    name = "denodo"
+
+    def __init__(self, name: str, **kwargs) -> None:
+        super().__init__(name)
+        self.parser = parse_sql
+        self.dialect = "mysql"
+        self.connection_data = kwargs.get("connection_data", {})
+        self.database = self.connection_data.get("database")
+
+        self.connection = None
+
+    def connect(self) -> Optional[dbdriver.extensions.connection]:
+        """
+        Connect to the Denodo database using the connection data provided.
+
+        Returns:
+            Optional[dbdriver.extensions.connection]: A connection object if successful, None otherwise.
+        """
+        if self.connection is not None:
+            return self.connection
+
+        try:
+            self.connection = dbdriver.connect(
+                host=self.connection_data.get("host"),
+                port=self.connection_data.get("port"),
+                user=self.connection_data.get("user"),
+                password=self.connection_data.get("password"),
+                database=self.connection_data.get("database"),
+            )
+            return self.connection
+        except (OperationalError, InterfaceError) as e:
+            logger.error(f"Error connecting to Denodo: {str(e)}")
+            raise ConnectionError(f"Failed to connect to Denodo: {str(e)}")
+
+    def disconnect(self) -> None:
+        """
+        Safely close the database connection.
+        """
+        if self.connection is not None:
+            self.connection.close()
+            self.connection = None
+
+    def _validate_connection(self) -> None:
+        """
+        Check if the connection is still active and reconnect if necessary.
+        """
+        if not self.connection:
+            self.connect()
+        try:
+            with self.connection.cursor() as cursor:
+                cursor.execute("SELECT 1")
+        except (OperationalError, InterfaceError):
+            self.connect()
+
+    def check_connection(self) -> StatusResponse:
+        """
+        Check if the connection is still active.
+
+        Returns:
+            StatusResponse: A response object containing the status of the connection.
+        """
+        try:
+            self._validate_connection()
+            return StatusResponse(True)
+        except Exception as e:
+            logger.error(f"Connection check failed: {str(e)}")
+            return StatusResponse(False, str(e))
+
+    def native_query(self, query: str) -> Response:
+        """
+        Executes a VQL query on the Denodo database and returns the result.
+
+        Args:
+            query (str): The VQL query to be executed.
+
+        Returns:
+            Response: A response object containing the result of the query or an error message.
+        """
+        self._validate_connection()
+
+        try:
+            connection = self.connect()
+            with connection.cursor() as cur:
+                cur.execute(query)
+                if cur.description is not None:
+                    columns = [desc[0] for desc in cur.description]
+                    result = cur.fetchall()
+                    response = Response(
+                        resp_type=RESPONSE_TYPE.TABLE,
+                        query=query,
+                        data_frame=pd.DataFrame(result, columns=columns),
+                    )
+                else:
+                    response = Response(RESPONSE_TYPE.OK)
+
+        except (OperationalError, InterfaceError, ProgrammingError) as e:
+            logger.error(f"Error running query: {query} on {self.database}!")
+            response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
+
+        return response
+
+    def query(self, query: ASTNode) -> Response:
+        """
+        Execute a SQL query and return results.
+        """
+        renderer = SqlalchemyRender(self.dialect)
+        query_str = renderer.get_string(query, with_failback=True)
+        return self.native_query(query_str)
+
+    def get_tables(self) -> Response:
+        """
+        Get all tables in current schema.
+        """
+        query = "SELECT name FROM GET_VIEWS();"
+        result = self.native_query(query)
+        df = result.data_frame.rename(columns={"name": "TABLE_NAME"})
+        result.data_frame = df
+        return result
+
+    def get_columns(self, table_name: str) -> Response:
+        """
+        Get columns for specified table using parameterized query.
+        """
+        query = f"CALL GET_VIEW_COLUMNS('{self.database}', '{table_name}');"
+        result = self.native_query(query)
+        df = result.data_frame.rename(columns={"column_name": "COLUMN_NAME", "data_type": "DATA_TYPE"})
+        result.data_frame = df
+        return result
diff --git a/mindsdb/integrations/handlers/denodo_handler/icon.png b/mindsdb/integrations/handlers/denodo_handler/icon.png
new file mode 100644
index 00000000000..f7d20018201
Binary files /dev/null and b/mindsdb/integrations/handlers/denodo_handler/icon.png differ
diff --git a/mindsdb/integrations/handlers/duckdb_faiss_handler/duckdb_faiss_handler.py b/mindsdb/integrations/handlers/duckdb_faiss_handler/duckdb_faiss_handler.py
index dc536a6430f..22153163ae8 100644
--- a/mindsdb/integrations/handlers/duckdb_faiss_handler/duckdb_faiss_handler.py
+++ b/mindsdb/integrations/handlers/duckdb_faiss_handler/duckdb_faiss_handler.py
@@ -1,21 +1,15 @@
 import os
-from typing import List
+import re
+import shutil
+import threading
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Iterator
 
 import pandas as pd
-import orjson
-import duckdb
-from mindsdb_sql_parser.ast import (
-    Select,
-    Delete,
-    Identifier,
-    BinaryOperation,
-    Constant,
-    NullConstant,
-    Star,
-    Tuple as AstTuple,
-    Function,
-    TypeCast,
-)
+
 
 from mindsdb.integrations.libs.response import (
     RESPONSE_TYPE,
@@ -25,7 +19,6 @@
 from mindsdb.integrations.libs.vectordatabase_handler import (
     FilterCondition,
     VectorStoreHandler,
-    FilterOperator,
 )
 from mindsdb.integrations.libs.keyword_search_base import KeywordSearchBase
 from mindsdb.integrations.utilities.sql_utils import KeywordSearchArgs
@@ -33,11 +26,21 @@
 from mindsdb.utilities import log
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 
-from .faiss_index import FaissIVFIndex
+from .duckdb_faiss_table import DuckDBFaissTable
 
 logger = log.getLogger(__name__)
 
 
+TABLE_CACHE_TTL_SECONDS = 60
+
+
+@dataclass
+class TableCacheEntry:
+    table: DuckDBFaissTable
+    last_used_ts: float
+    in_use_count: int = 0
+
+
 class DuckDBFaissHandler(VectorStoreHandler, KeywordSearchBase):
     """This handler handles connection and execution of DuckDB with Faiss vector indexing."""
 
@@ -61,173 +64,206 @@ def __init__(self, name: str, **kwargs):
                 raise ValueError(f"Persist directory {self.persist_directory} does not exist")
         else:
             # Use default handler storage
-            self.persist_directory = self.handler_storage.folder_get("data")
+            self.persist_directory = self.handler_storage.folder_get("")
             self._use_handler_storage = True
 
-        # DuckDB connection
-        self.connection = None
-        self.is_connected = False
-
-        # Initialize storage paths
-        self.duckdb_path = os.path.join(self.persist_directory, "duckdb.db")
-        self.faiss_index_path = os.path.join(self.persist_directory, "faiss_index")
-        self.connect()
-
-        # check keyword index
-        self.is_kw_index_enabled = False
-        with self.connection.cursor() as cur:
-            # check index exists
-            df = cur.execute(
-                "SELECT * FROM information_schema.schemata WHERE schema_name = 'fts_main_meta_data'"
-            ).fetchdf()
-            if len(df) > 0:
-                self.is_kw_index_enabled = True
-
-    def connect(self) -> duckdb.DuckDBPyConnection:
-        """Connect to DuckDB database."""
-        if self.is_connected:
-            return self.connection
+        Path(self.persist_directory).mkdir(parents=True, exist_ok=True)
 
-        try:
-            self.connection = duckdb.connect(self.duckdb_path)
-            self.faiss_index = FaissIVFIndex(self.faiss_index_path, self.connection_data)
-            self.is_connected = True
+        self.tables_cache = {}
+        self.tables_cache_lock = threading.Lock()
 
-            logger.info("Connected to DuckDB database")
-            return self.connection
+    def connect(self):
+        """
+        Handler readiness check.
+        Must not open long-lived DuckDB/FAISS resources; tables are opened per operation.
+        """
 
-        except Exception as e:
-            logger.error(f"Error connecting to DuckDB: {e}")
-            raise
+        self.is_connected = True
+        return True
 
     def disconnect(self):
-        """Close DuckDB connection."""
-        if self.is_connected and self.connection:
-            self.connection.close()
-            self.faiss_index.close()
-            self.is_connected = False
-
-    def create_table(self, table_name: str, if_not_exists=True):
-        with self.connection.cursor() as cur:
-            cur.execute("CREATE SEQUENCE  IF NOT EXISTS faiss_id_sequence START 1")
-
-            cur.execute("""
-                CREATE TABLE IF NOT EXISTS meta_data (
-                    faiss_id INTEGER PRIMARY KEY DEFAULT nextval('faiss_id_sequence'), -- id in FAISS index 
-                    id TEXT  NOT NULL, -- chunk id                    
-                    content TEXT,
-                    metadata JSON
-                )
-            """)
-
-    def drop_table(self, table_name: str, if_exists=True):
-        """Drop table from both DuckDB and Faiss."""
-        with self.connection.cursor() as cur:
-            drop_sql = f"DROP TABLE {'IF EXISTS' if if_exists else ''} meta_data"
-            cur.execute(drop_sql)
+        with self.tables_cache_lock:
+            for item in self.tables_cache.values():
+                item.table.close()
 
-        if self.faiss_index:
-            self.faiss_index.drop()
+            self.tables_cache = {}
 
-    def create_index(self, table_name: str, type: str = "ivf", nlist: int = 1024, train_count: int = 10000):
-        if type != "ivf":
-            raise NotImplementedError("Only ivf index is supported")
-
-        self.faiss_index.create_index(nlist=nlist, train_count=train_count)
+    def check_connection(self) -> Response:
+        """Check the connection to the database."""
+        try:
+            if not self.is_connected:
+                self.connect()
+            return StatusResponse(RESPONSE_TYPE.OK)
+        except Exception as e:
+            logger.error(f"Connection check failed: {e}")
+            return StatusResponse(RESPONSE_TYPE.ERROR, error_message=str(e))
 
-    def insert(self, table_name: str, data: pd.DataFrame):
-        """Insert data into both DuckDB and Faiss."""
+    def __del__(self):
+        """Cleanup on deletion."""
+        self.disconnect()
+
+    # -- manage tables --
+
+    @staticmethod
+    def _validate_table_name(table_name: str) -> None:
+        if table_name in (".", ".."):
+            raise ValueError("Invalid table_name")
+        if "/" in table_name or "\\" in table_name:
+            raise ValueError("table_name must not contain path separators")
+        if not re.fullmatch(r"[A-Za-z0-9_-]+", table_name):
+            raise ValueError(
+                "Invalid table_name: only letters, digits, '_' and '-' are allowed (no spaces, dots, or other symbols)"
+            )
 
-        if self.is_kw_index_enabled:
-            # drop index, it will be created before a first keyword search
-            self.drop_kw_index()
+    def get_table_dir(self, table_name: str) -> Path:
+        """
+        Get folder for a table name
+        Prevent path traversal by requiring the resolved path to stay within persist_directory.
+        """
+        root = Path(self.persist_directory).resolve()
+        table_dir = (Path(self.persist_directory) / table_name).resolve()
+        if table_dir == root or root not in table_dir.parents:
+            raise ValueError("Invalid table_name path")
+        return table_dir
+
+    def _close_cached_table(self, table_name: str) -> None:
+        entry = self.tables_cache.pop(table_name, None)
+        if entry is None:
+            return
+        try:
+            entry.table.close()
+        except Exception:
+            logger.exception("Failed to close cached table '%s'", table_name)
 
-        with self.connection.cursor() as cur:
-            df_ids = cur.execute("""
-                insert into meta_data (id, content, metadata) (
-                    select id, content, metadata from data
-                )
-                RETURNING faiss_id, id
-            """).fetchdf()
+    def _close_old_tables_cache(self):
+        """
+        Close stale cached tables that have not been used for more than TTL.
+        Tables that are currently in use are never closed by pruning.
+        """
+        if not self.tables_cache:
+            return
+
+        with self.tables_cache_lock:
+            now_ts = time.time()
+            to_close: List[str] = []
+            for table_name, entry in self.tables_cache.items():
+                if entry.in_use_count > 0:
+                    continue
+                if now_ts - entry.last_used_ts > TABLE_CACHE_TTL_SECONDS:
+                    to_close.append(table_name)
+
+            for table_name in to_close:
+                self._close_cached_table(table_name)
+
+    @contextmanager
+    def open_table(self, table_name: str) -> Iterator[DuckDBFaissTable]:
+        """
+        Open DuckDB and Faiss resources scoped to one vector table.
+        Must always be closed after use to avoid long-lived locks / RAM usage.
 
-        data = data.merge(df_ids, on="id")
+        If `use_cache=True` and `table.cache_required` is True, the opened table is cached
+        in `self.tables_cache` and re-used across calls. Cached tables are pruned if they
+        haven't been used for more than TABLE_CACHE_TTL_SECONDS.
+        """
+        table_dir = self.get_table_dir(table_name)
+        if not table_dir.exists():
+            raise ValueError(f"Table '{table_name}' does not exist")
 
-        vectors = data["embeddings"]
-        ids = data["faiss_id"]
+        with self.tables_cache_lock:
+            entry = self.tables_cache.get(table_name)
 
-        self.faiss_index.insert(list(vectors), list(ids))
-        self._sync()
+            if entry is not None:
+                table = entry.table
+            else:
+                table = DuckDBFaissTable(table_name=table_name, table_dir=table_dir, handler=self).open()
 
-    # def upsert(self, table_name: str, data: pd.DataFrame):
-    #     # delete by ids and insert
-    #     ids = list(data['id'])
-    #     self.delete(table_name, [FilterCondition(column='id', op=FilterOperator.IN, value=ids)])
-    #     self.insert(table_name, data)
+                if table.cache_required:
+                    entry = TableCacheEntry(table=table, last_used_ts=time.time())
+                    self.tables_cache[table_name] = entry
 
-    def select(
-        self,
-        table_name: str,
-        columns: List[str] = None,
-        conditions: List[FilterCondition] = None,
-        offset: int = None,
-        limit: int = None,
-    ) -> pd.DataFrame:
-        """Select data with hybrid search logic."""
-
-        vector_filter = None
-        meta_filters = []
-        if conditions is None:
-            conditions = []
-        for condition in conditions:
-            if condition.column == "embeddings":
-                vector_filter = condition
+        try:
+            if entry:
+                with self.tables_cache_lock:
+                    entry.in_use_count += 1
+
+            yield table
+        finally:
+            if entry:
+                entry.in_use_count -= 1
+                entry.last_used_ts = time.time()
             else:
-                meta_filters.append(condition)
+                table.close()
 
-        if vector_filter is None:
-            # If only metadata in filter:
-            # query duckdb only
-            return self._select_from_metadata(meta_filters=meta_filters, limit=limit).drop("faiss_id", axis=1)
+        self._close_old_tables_cache()
 
-        # vector_filter is not None
-        if not meta_filters:
-            # If only content in filter: query faiss and attach to metadata
-            return self._select_with_vector(vector_filter=vector_filter, limit=limit)
+    def create_table(self, table_name: str, if_not_exists=True):
+        self._validate_table_name(table_name)
+        table_dir = self.get_table_dir(table_name)
+        if table_dir.exists() and not if_not_exists:
+            raise ValueError(f"Vector table '{table_name}' already exists")
+        table_dir.mkdir(parents=True, exist_ok=True)
+
+        with self.open_table(table_name) as table:
+            with table.connection.cursor() as cur:
+                cur.execute("CREATE SEQUENCE IF NOT EXISTS faiss_id_sequence START 1")
+                cur.execute("""
+                    CREATE TABLE IF NOT EXISTS meta_data (
+                        faiss_id INTEGER PRIMARY KEY DEFAULT nextval('faiss_id_sequence'), -- id in FAISS index
+                        id TEXT NOT NULL, -- chunk id
+                        content TEXT,
+                        metadata JSON
+                    )
+                """)
 
-        """
-        If metadata + content:
-        Query faiss, use limit = 1000
-        Query duckdb with `id in (...)` 
-        If count of results is less than input LIMIT value
-        Repeat the search with increased limit value
-        Limit value for step = 1000 * 5^i  (1000, 2000, 25000, 125000 …)
-        """
+    def drop_table(self, table_name: str, if_exists=True):
+        """Drop table from both DuckDB and Faiss."""
+        table_dir = self.get_table_dir(table_name)
 
-        df = pd.DataFrame()
+        if not table_dir.exists():
+            if if_exists:
+                return
+            raise ValueError(f"Vector table '{table_name}' does not exist")
 
-        total_size = self.get_total_size()
+        with self.tables_cache_lock:
+            self._close_cached_table(table_name)
 
-        for i in range(10):
-            batch_size = 1000 * 5**i
+        shutil.rmtree(table_dir, ignore_errors=False)
 
-            # TODO implement reverse search:
-            #   if batch_size > 25% of db: search metadata first and then in faiss by list of ids
+        if self._use_handler_storage:
+            self.handler_storage.folder_sync(table_name)
 
-            df = self._select_with_vector(vector_filter=vector_filter, meta_filters=meta_filters, limit=batch_size)
-            if batch_size >= total_size or len(df) >= limit:
-                break
+    def get_tables(self) -> Response:
+        """Get list of tables."""
+        rows = []
+        root = Path(self.persist_directory)
+        if root.exists():
+            for item in root.iterdir():
+                if not item.is_dir():
+                    continue
+                rows.append({"table_name": item.name})
+        df = pd.DataFrame(rows, columns=["table_name"])
+        return Response(RESPONSE_TYPE.TABLE, data_frame=df)
 
-        return df[:limit]
+    # -- table methods --
 
-    def create_kw_index(self):
-        with self.connection.cursor() as cur:
-            cur.execute("PRAGMA create_fts_index('meta_data', 'id', 'content')")
-            self.is_kw_index_enabled = True
+    def create_index(self, table_name: str, type: str = None, nlist: int = None, train_count: int = None):
+        with self.open_table(table_name) as table:
+            table.create_index(type=type, nlist=nlist, train_count=train_count)
 
-    def drop_kw_index(self):
-        with self.connection.cursor() as cur:
-            cur.execute("pragma drop_fts_index('meta_data')")
-            self.is_kw_index_enabled = False
+    def insert(self, table_name: str, data: pd.DataFrame):
+        with self.open_table(table_name) as table:
+            table.insert(data)
+
+    def select(
+        self,
+        table_name: str,
+        columns: List[str] = None,
+        conditions: List[FilterCondition] = None,
+        offset: int = None,
+        limit: int = None,
+    ) -> pd.DataFrame:
+        with self.open_table(table_name) as table:
+            return table.select(conditions=conditions, offset=offset, limit=limit)
 
     def keyword_select(
         self,
@@ -238,229 +274,20 @@ def keyword_select(
         limit: int = None,
         keyword_search_args: KeywordSearchArgs = None,
     ) -> pd.DataFrame:
-        if not self.is_kw_index_enabled:
-            # keyword search is used for first time: create index
-            self.create_kw_index()
-
-        with self.connection.cursor() as cur:
-            where_clause = self._translate_filters(conditions)
-
-            score = Function(
-                namespace="fts_main_meta_data",
-                op="match_bm25",
-                args=[
-                    Identifier("id"),
-                    Constant(keyword_search_args.query),
-                    BinaryOperation(op=":=", args=[Identifier("fields"), Constant(keyword_search_args.column)]),
-                ],
+        with self.open_table(table_name) as table:
+            return table.keyword_select(
+                conditions=conditions,
+                offset=offset,
+                limit=limit,
+                keyword_search_args=keyword_search_args,
             )
 
-            no_emtpy_score = BinaryOperation(op="is not", args=[score, NullConstant()])
-            if where_clause:
-                where_clause = BinaryOperation(op="and", args=[where_clause, no_emtpy_score])
-            else:
-                where_clause = no_emtpy_score
-
-            query = Select(
-                targets=[Star(), BinaryOperation(op="-", args=[Constant(1), score], alias=Identifier("distance"))],
-                from_table=Identifier("meta_data"),
-                where=where_clause,
-            )
-
-            sql = self.renderer.get_string(query, with_failback=True)
-            cur.execute(sql)
-            df = cur.fetchdf()
-            df["metadata"] = df["metadata"].apply(orjson.loads)
-            return df
-
-    def get_total_size(self):
-        with self.connection.cursor() as cur:
-            cur.execute("select count(1) size from meta_data")
-            df = cur.fetchdf()
-            return df["size"].iloc[0]
-
-    def _select_with_vector(self, vector_filter: FilterCondition, meta_filters=None, limit=None) -> pd.DataFrame:
-        embedding = vector_filter.value
-        if isinstance(embedding, str):
-            embedding = orjson.loads(embedding)
-
-        distances, faiss_ids = self.faiss_index.search(embedding, limit or 100)
-
-        # Fetch full data from DuckDB
-        if len(faiss_ids) > 0:
-            # ids = [str(idx) for idx in faiss_ids]
-            meta_df = self._select_from_metadata(faiss_ids=faiss_ids, meta_filters=meta_filters)
-            vector_df = pd.DataFrame({"faiss_id": faiss_ids, "distance": distances})
-            return vector_df.merge(meta_df, on="faiss_id").drop("faiss_id", axis=1).sort_values(by="distance")
-
-        return pd.DataFrame([], columns=["id", "content", "metadata", "distance"])
-
-    def _select_from_metadata(self, faiss_ids=None, meta_filters=None, limit=None):
-        query = Select(
-            targets=[Star()],
-            from_table=Identifier("meta_data"),
-        )
-
-        where_clause = self._translate_filters(meta_filters)
-
-        if faiss_ids:
-            # TODO what if ids list is too long - split search into batches
-            in_filter = BinaryOperation(
-                op="IN", args=[Identifier("faiss_id"), AstTuple([Constant(i) for i in faiss_ids])]
-            )
-            # split into chunks
-            chunk_size = 10000
-            if len(faiss_ids) > chunk_size:
-                dfs = []
-                chunk = 0
-                total = 0
-                while chunk * chunk_size < len(faiss_ids):
-                    # create results with partition
-                    ids = faiss_ids[chunk * chunk_size : (chunk + 1) * chunk_size]
-                    chunk += 1
-                    df = self._select_from_metadata(faiss_ids=ids, meta_filters=meta_filters, limit=limit)
-                    total += len(df)
-                    if limit is not None and limit <= total:
-                        # cut the extra from the end
-                        df = df[: -(total - limit)]
-                        dfs.append(df)
-                        break
-                    if len(df) > 0:
-                        dfs.append(df)
-                if len(dfs) == 0:
-                    return pd.DataFrame([], columns=["faiss_id", "id", "content", "metadata"])
-                return pd.concat(dfs)
-
-            if where_clause is None:
-                where_clause = in_filter
-            else:
-                where_clause = BinaryOperation(op="AND", args=[where_clause, in_filter])
-
-        if limit is not None:
-            query.limit = Constant(limit)
-
-        query.where = where_clause
-
-        with self.connection.cursor() as cur:
-            sql = self.renderer.get_string(query, with_failback=True)
-            cur.execute(sql)
-            df = cur.fetchdf()
-            df["metadata"] = df["metadata"].apply(orjson.loads)
-            return df
-
-    def _translate_filters(self, meta_filters):
-        if not meta_filters:
-            return None
-
-        where_clause = None
-        for item in meta_filters:
-            parts = item.column.split(".")
-            key = Identifier(parts[0])
-
-            # converts 'col.el1.el2' to col->'el1'->>'el2'
-            if len(parts) > 1:
-                # intermediate elements
-                for el in parts[1:-1]:
-                    key = BinaryOperation(op="->", args=[key, Constant(el)])
-
-                # last element
-                key = BinaryOperation(op="->>", args=[key, Constant(parts[-1])])
-
-            is_orig_id = item.column == "metadata._original_doc_id"
-
-            type_cast = None
-            value = item.value
-
-            if isinstance(value, list) and len(value) > 0 and item.op in (FilterOperator.IN, FilterOperator.NOT_IN):
-                if is_orig_id:
-                    # convert to str
-                    item.value = [str(i) for i in value]
-                value = item.value[0]
-            elif is_orig_id:
-                if not isinstance(value, str):
-                    value = item.value = str(item.value)
-
-            if isinstance(value, int):
-                type_cast = "int"
-            elif isinstance(value, float):
-                type_cast = "float"
-
-            if type_cast is not None:
-                key = TypeCast(type_cast, key)
-
-            if item.op in (FilterOperator.NOT_IN, FilterOperator.IN):
-                values = [Constant(i) for i in item.value]
-                value = AstTuple(values)
-            else:
-                value = Constant(item.value)
-
-            condition = BinaryOperation(op=item.op.value, args=[key, value])
-
-            if where_clause is None:
-                where_clause = condition
-            else:
-                where_clause = BinaryOperation(op="AND", args=[where_clause, condition])
-        return where_clause
-
-    def delete(self, table_name: str, conditions: List[FilterCondition] = None) -> Response:
+    def delete(self, table_name: str, conditions: List[FilterCondition] = None):
         """Delete data from both DuckDB and Faiss."""
 
-        with self.connection.cursor() as cur:
-            where_clause = self._translate_filters(conditions)
-
-            query = Select(targets=[Identifier("faiss_id")], from_table=Identifier("meta_data"), where=where_clause)
-            cur.execute(self.renderer.get_string(query, with_failback=True))
-            df = cur.fetchdf()
-            ids = list(df["faiss_id"])
-
-            self.faiss_index.delete_ids(ids)
-
-            query = Delete(table=Identifier("meta_data"), where=where_clause)
-            cur.execute(self.renderer.get_string(query, with_failback=True))
-
-            self._sync()
+        with self.open_table(table_name) as table:
+            table.delete(conditions)
 
     def get_dimension(self, table_name: str) -> int:
-        if self.faiss_index:
-            return self.faiss_index.dim
-
-    def _sync(self):
-        """Sync the database to disk if using persistent storage"""
-        self.faiss_index.dump()
-        if self._use_handler_storage:
-            self.handler_storage.folder_sync(self.persist_directory)
-
-    def get_tables(self) -> Response:
-        """Get list of tables."""
-        with self.connection.cursor() as cur:
-            df = cur.execute("show tables").fetchdf()
-            df = df.rename(columns={"name": "table_name"})
-
-        return Response(RESPONSE_TYPE.TABLE, data_frame=df)
-
-    def check_connection(self) -> Response:
-        """Check the connection to the database."""
-        try:
-            if not self.is_connected:
-                self.connect()
-            return StatusResponse(RESPONSE_TYPE.OK)
-        except Exception as e:
-            logger.error(f"Connection check failed: {e}")
-            return StatusResponse(RESPONSE_TYPE.ERROR, error_message=str(e))
-
-    def native_query(self, query: str) -> Response:
-        """Execute a native SQL query."""
-        try:
-            with self.connection.cursor() as cur:
-                cur.execute(query)
-                result = cur.fetchdf()
-                return Response(RESPONSE_TYPE.TABLE, data_frame=result)
-        except Exception as e:
-            logger.error(f"Error executing native query: {e}")
-            return Response(RESPONSE_TYPE.ERROR, error_message=str(e))
-
-    def __del__(self):
-        """Cleanup on deletion."""
-        if self.is_connected:
-            self._sync()
-            self.disconnect()
+        with self.open_table(table_name) as table:
+            return table.get_dimension()
diff --git a/mindsdb/integrations/handlers/duckdb_faiss_handler/duckdb_faiss_table.py b/mindsdb/integrations/handlers/duckdb_faiss_handler/duckdb_faiss_table.py
new file mode 100644
index 00000000000..3ee59e93c01
--- /dev/null
+++ b/mindsdb/integrations/handlers/duckdb_faiss_handler/duckdb_faiss_table.py
@@ -0,0 +1,496 @@
+from pathlib import Path
+from typing import List
+import math
+
+import pandas as pd
+import orjson
+import duckdb
+from mindsdb_sql_parser.ast import (
+    Select,
+    Delete,
+    Identifier,
+    BinaryOperation,
+    Constant,
+    NullConstant,
+    Star,
+    Tuple as AstTuple,
+    Function,
+    TypeCast,
+)
+
+
+from mindsdb.integrations.libs.vectordatabase_handler import (
+    FilterCondition,
+    FilterOperator,
+)
+from mindsdb.integrations.utilities.sql_utils import KeywordSearchArgs
+
+from mindsdb.utilities import log
+
+from .faiss_index import FaissIVFIndex
+
+logger = log.getLogger(__name__)
+
+
+class DuckDBFaissTable:
+    META_BATCH_SIZE = 10_000
+    VECTOR_MARGIN_K = 5
+    VECTOR_GROWTH_MULTIPLIER = 5
+    VECTOR_MAX_RATE = 0.25
+    VECTOR_MAX_LIMIT = 1_000_000
+    VECTOR_MAX_ITERATIONS = 3
+    DEFAULT_LIMIT = 100
+
+    def __init__(self, table_name: str, table_dir: Path, handler):
+        self.table_name = table_name
+        self.handler = handler
+        self.connection: duckdb.DuckDBPyConnection | None = None
+        self.faiss_index: FaissIVFIndex | None = None
+        self.table_dir = table_dir
+        self.is_kw_index_enabled = False
+        self.cache_required = False
+
+    def open(self) -> "DuckDBFaissTable":
+        duckdb_path = self.table_dir / "duckdb.db"
+        self.connection = duckdb.connect(str(duckdb_path))
+        self.faiss_index = FaissIVFIndex(str(self.table_dir), self.handler.connection_data)
+
+        self.cache_required = self.faiss_index.lock_required and self.faiss_index.get_size() > 100_000
+
+        # check keyword index
+        with self.connection.cursor() as cur:
+            # check index exists
+            df = cur.execute(
+                "SELECT * FROM information_schema.schemata WHERE schema_name = 'fts_main_meta_data'"
+            ).fetchdf()
+            if len(df) > 0:
+                self.is_kw_index_enabled = True
+
+        return self
+
+    def close(self) -> None:
+        self.faiss_index.close()
+        self.connection.close()
+
+    @staticmethod
+    def _empty_result() -> pd.DataFrame:
+        return pd.DataFrame([], columns=["id", "content", "metadata", "distance"])
+
+    def _create_kw_index(self):
+        with self.connection.cursor() as cur:
+            cur.execute("PRAGMA create_fts_index('meta_data', 'id', 'content')")
+            self.is_kw_index_enabled = True
+
+    def _drop_kw_index(self):
+        with self.connection.cursor() as cur:
+            cur.execute("pragma drop_fts_index('meta_data')")
+            self.is_kw_index_enabled = False
+
+    def _sync(self, dump_faiss=True):
+        if dump_faiss:
+            self.faiss_index.dump()
+
+        if self.handler._use_handler_storage:
+            self.handler.handler_storage.folder_sync(self.table_name)
+
+    def create_index(self, type: str = None, nlist: int = None, train_count: int = None):
+        self.faiss_index.create_index(type, nlist=nlist, train_count=train_count)
+        # index was already saved. don't dump it twice
+        self._sync(dump_faiss=False)
+
+    def insert(self, data: pd.DataFrame):
+        """Insert data into both DuckDB and Faiss."""
+
+        if self.is_kw_index_enabled:
+            # drop index, it will be created before a first keyword search
+            self._drop_kw_index()
+
+        with self.connection.cursor() as cur:
+            df_ids = cur.execute("""
+                insert into meta_data (id, content, metadata) (
+                    select id, content, metadata from data
+                )
+                RETURNING faiss_id, id
+            """).fetchdf()
+
+        data = data.merge(df_ids, on="id")
+
+        vectors = data["embeddings"]
+        ids = data["faiss_id"]
+
+        self.faiss_index.insert(list(vectors), list(ids))
+        self._sync()
+
+    def select(
+        self,
+        conditions: List[FilterCondition] = None,
+        offset: int = None,
+        limit: int = None,
+    ) -> pd.DataFrame:
+        """Select data with hybrid search logic."""
+
+        vector_filter = None
+        meta_filters = []
+        if conditions is None:
+            conditions = []
+        for condition in conditions:
+            if condition.column == "embeddings":
+                vector_filter = condition
+            else:
+                meta_filters.append(condition)
+
+        if vector_filter is None:
+            # If only metadata in filter:
+            # query duckdb only
+            return self._select_from_metadata(meta_filters=meta_filters, limit=limit).drop("faiss_id", axis=1)
+
+        # vector_filter is not None
+        if not meta_filters:
+            # If only content in filter: query faiss and attach to metadata
+            return self._select_with_vector(vector_filter=vector_filter, limit=limit)
+
+        return self.mixed_search(vector_filter=vector_filter, meta_filters=meta_filters, limit=limit)
+
+    def mixed_search(self, vector_filter, meta_filters, limit):
+        """
+        1. Measure selectivity of META_FILTERS:
+            Get predicted count of record after applying META_FILTERS using some of methods
+            Selectivity = count / total records
+
+        2. selectivity * total_recors > LIMIT / selectivity:
+            Use Vector-first search
+        Else:
+            Use Metadata-first search
+        """
+
+        if limit is None:
+            limit = self.DEFAULT_LIMIT
+
+        total = self.faiss_index.get_size()
+        if total == 0 or limit == 0:
+            # no reason to do vector search
+            return self._empty_result()
+
+        matched_count = self.get_metadata_search_count(meta_filters)
+        selectivity = matched_count / total
+
+        # compare forecast count of affected records for vector and metadata search and choose what will take less
+        # do search even if selectivity is 0 because it might be approximate value in the future
+        if selectivity > 0 and selectivity * total > limit / selectivity:
+            df = self.vector_first_search(vector_filter, meta_filters, limit, selectivity)
+        else:
+            df = self.metadata_first_search(vector_filter, meta_filters, limit)
+
+        return df[:limit]
+
+    def get_metadata_search_count(self, meta_filters):
+        """
+        Get count of records from duckdb with meta_filters
+        """
+
+        where_clause = self._translate_filters(meta_filters)
+        count_query = Select(
+            targets=[Function("count", args=[Star()], alias=Identifier("cnt"))],
+            from_table=Identifier("meta_data"),
+            where=where_clause,
+        )
+
+        with self.connection.cursor() as cur:
+            sql = self.handler.renderer.get_string(count_query, with_failback=True)
+            cur.execute(sql)
+            df = cur.fetchdf()
+
+        return int(df["cnt"].iloc[0])
+
+    def vector_first_search(self, vector_filter, meta_filters, limit, selectivity):
+        """
+
+        Calculate required top results from faiss: it is predicted count of records, that required to be scanned
+
+        Top_results  = LIMIT / selectivity * VECTOR_MARGIN_K
+
+        Circle:
+            Search Top_results vectors in faiss
+            Get ids
+            query duckdb with META_FILTERS and list of ids
+            If count of found records < LIMIT:
+                Increase Top_results = Top_results * VECTOR_GROWTH_MULTIPLIER to make next search iteration
+                If Top_results > total * VECTOR_MAX_RATE
+                   or Top_results > VECTOR_MAX_LIMIT
+                   or number of iteration >VECTOR_MAX_ITERATIONS:
+                     Something went wrong, maybe META_FILTERS records has greater distance than average record
+                     Break vector-first search and switch to metadata-first
+            If count of found records >= LIMIT:
+                Break and return results
+        """
+
+        total = self.faiss_index.get_size()
+
+        top_results = math.ceil(limit / selectivity * self.VECTOR_MARGIN_K)
+
+        for i in range(self.VECTOR_MAX_ITERATIONS):
+            df = self._select_with_vector(vector_filter=vector_filter, meta_filters=meta_filters, limit=top_results)
+            if len(df) >= limit:
+                # found required size of data
+                return df
+
+            top_results = top_results * self.VECTOR_GROWTH_MULTIPLIER
+
+            if top_results > total * self.VECTOR_MAX_RATE or top_results > self.VECTOR_MAX_LIMIT:
+                # give up with vector_first search
+                break
+
+        # failback to metadata-first search
+        return self.metadata_first_search(vector_filter, meta_filters, limit)
+
+    def metadata_first_search(self, vector_filter, meta_filters, limit):
+        """
+        Metadata-first search
+
+        Query list of all ids from duckdb table using META_FILTERS
+
+        Split into batches by META_BATCH.
+        Per batch:
+            Get batch of ids
+            Use ID selector to search in FAISS only by batch of ids
+            use LIMIT
+            Combine results in single list alongside with distances
+        After all batches
+            get top LIMIT vectors with min distances
+            Get their ids and find records in duckdb table for them
+        """
+
+        embedding = vector_filter.value
+        if isinstance(embedding, str):
+            embedding = orjson.loads(embedding)
+
+        where_clause = self._translate_filters(meta_filters)
+        ids_query = Select(
+            targets=[Identifier("faiss_id")],
+            from_table=Identifier("meta_data"),
+            where=where_clause,
+        )
+
+        with self.connection.cursor() as cur:
+            sql = self.handler.renderer.get_string(ids_query, with_failback=True)
+            meta_df = cur.execute(sql).fetchdf()
+
+        if meta_df.empty:
+            return self._empty_result()
+
+        faiss_ids = meta_df["faiss_id"].tolist()
+        results = []
+        for start in range(0, len(faiss_ids), self.META_BATCH_SIZE):
+            batch_ids = faiss_ids[start : start + self.META_BATCH_SIZE]
+
+            distances, faiss_ids_found = self.faiss_index.search(embedding, limit, allowed_ids=batch_ids)
+            results.extend(zip(distances, faiss_ids_found))
+
+        results.sort(key=lambda x: x[0])
+
+        results = results[:limit]
+        if len(results) == 0:
+            raise RuntimeError("Something went wrong, faiss database didn't return results")
+        distances, faiss_ids = zip(*results)
+
+        meta_df = self._select_from_metadata(faiss_ids=faiss_ids, meta_filters=meta_filters)
+        vector_df = pd.DataFrame({"faiss_id": faiss_ids, "distance": distances})
+        return vector_df.merge(meta_df, on="faiss_id").drop("faiss_id", axis=1).sort_values(by="distance")
+
+    def keyword_select(
+        self,
+        conditions: List[FilterCondition] = None,
+        offset: int = None,
+        limit: int = None,
+        keyword_search_args: KeywordSearchArgs = None,
+    ) -> pd.DataFrame:
+        if not self.is_kw_index_enabled:
+            # keyword search is used for first time: create index
+            self._create_kw_index()
+
+        with self.connection.cursor() as cur:
+            where_clause = self._translate_filters(conditions)
+
+            score = Function(
+                namespace="fts_main_meta_data",
+                op="match_bm25",
+                args=[
+                    Identifier("id"),
+                    Constant(keyword_search_args.query),
+                    BinaryOperation(op=":=", args=[Identifier("fields"), Constant(keyword_search_args.column)]),
+                ],
+            )
+
+            no_emtpy_score = BinaryOperation(op="is not", args=[score, NullConstant()])
+            if where_clause:
+                where_clause = BinaryOperation(op="and", args=[where_clause, no_emtpy_score])
+            else:
+                where_clause = no_emtpy_score
+
+            query = Select(
+                targets=[Star(), BinaryOperation(op="-", args=[Constant(1), score], alias=Identifier("distance"))],
+                from_table=Identifier("meta_data"),
+                where=where_clause,
+            )
+
+            if limit is not None:
+                query.limit = Constant(limit)
+
+            if offset is not None:
+                query.offset = Constant(offset)
+
+            sql = self.handler.renderer.get_string(query, with_failback=True)
+            cur.execute(sql)
+            df = cur.fetchdf()
+            df["metadata"] = df["metadata"].apply(orjson.loads)
+            return df
+
+    def delete(self, conditions: List[FilterCondition] = None):
+        """Delete data from both DuckDB and Faiss."""
+        with self.connection.cursor() as cur:
+            where_clause = self._translate_filters(conditions)
+
+            query = Select(targets=[Identifier("faiss_id")], from_table=Identifier("meta_data"), where=where_clause)
+            cur.execute(self.handler.renderer.get_string(query, with_failback=True))
+            df = cur.fetchdf()
+            ids = list(df["faiss_id"])
+
+            self.faiss_index.delete_ids(ids)
+
+            query = Delete(table=Identifier("meta_data"), where=where_clause)
+            cur.execute(self.handler.renderer.get_string(query, with_failback=True))
+
+        self._sync()
+
+    def get_dimension(self) -> int:
+        if self.faiss_index and self.faiss_index.index is not None:
+            return self.faiss_index.dim
+
+    def get_total_size(self):
+        with self.connection.cursor() as cur:
+            cur.execute("select count(1) size from meta_data")
+            df = cur.fetchdf()
+            return df["size"].iloc[0]
+
+    def _select_with_vector(self, vector_filter: FilterCondition, meta_filters=None, limit=None) -> pd.DataFrame:
+        embedding = vector_filter.value
+        if isinstance(embedding, str):
+            embedding = orjson.loads(embedding)
+
+        distances, faiss_ids = self.faiss_index.search(embedding, limit or self.DEFAULT_LIMIT)
+
+        # Fetch full data from DuckDB
+        if len(faiss_ids) > 0:
+            # ids = [str(idx) for idx in faiss_ids]
+            meta_df = self._select_from_metadata(faiss_ids=faiss_ids, meta_filters=meta_filters)
+            vector_df = pd.DataFrame({"faiss_id": faiss_ids, "distance": distances})
+            return vector_df.merge(meta_df, on="faiss_id").drop("faiss_id", axis=1).sort_values(by="distance")
+
+        return self._empty_result()
+
+    def _select_from_metadata(self, faiss_ids=None, meta_filters=None, limit=None):
+        query = Select(
+            targets=[Star()],
+            from_table=Identifier("meta_data"),
+        )
+
+        where_clause = self._translate_filters(meta_filters)
+
+        if faiss_ids:
+            # TODO what if ids list is too long - split search into batches
+            in_filter = BinaryOperation(
+                op="IN", args=[Identifier("faiss_id"), AstTuple([Constant(i) for i in faiss_ids])]
+            )
+            # split into chunks
+            chunk_size = 10000
+            if len(faiss_ids) > chunk_size:
+                dfs = []
+                chunk = 0
+                total = 0
+                while chunk * chunk_size < len(faiss_ids):
+                    # create results with partition
+                    ids = faiss_ids[chunk * chunk_size : (chunk + 1) * chunk_size]
+                    chunk += 1
+                    df = self._select_from_metadata(faiss_ids=ids, meta_filters=meta_filters, limit=limit)
+                    total += len(df)
+                    if limit is not None and limit <= total:
+                        # cut the extra from the end
+                        df = df[: -(total - limit)]
+                        dfs.append(df)
+                        break
+                    if len(df) > 0:
+                        dfs.append(df)
+                if len(dfs) == 0:
+                    return pd.DataFrame([], columns=["faiss_id", "id", "content", "metadata"])
+                return pd.concat(dfs)
+
+            if where_clause is None:
+                where_clause = in_filter
+            else:
+                where_clause = BinaryOperation(op="AND", args=[where_clause, in_filter])
+
+        if limit is not None:
+            query.limit = Constant(limit)
+
+        query.where = where_clause
+
+        with self.connection.cursor() as cur:
+            sql = self.handler.renderer.get_string(query, with_failback=True)
+            cur.execute(sql)
+            df = cur.fetchdf()
+            df["metadata"] = df["metadata"].apply(orjson.loads)
+            return df
+
+    def _translate_filters(self, meta_filters):
+        if not meta_filters:
+            return None
+
+        where_clause = None
+        for item in meta_filters:
+            parts = item.column.split(".")
+            key = Identifier(parts[0])
+
+            # converts 'col.el1.el2' to col->'el1'->>'el2'
+            if len(parts) > 1:
+                # intermediate elements
+                for el in parts[1:-1]:
+                    key = BinaryOperation(op="->", args=[key, Constant(el)])
+
+                # last element
+                key = BinaryOperation(op="->>", args=[key, Constant(parts[-1])])
+
+            is_orig_id = item.column == "metadata._original_doc_id"
+
+            type_cast = None
+            value = item.value
+
+            if isinstance(value, list) and len(value) > 0 and item.op in (FilterOperator.IN, FilterOperator.NOT_IN):
+                if is_orig_id:
+                    # convert to str
+                    item.value = [str(i) for i in value]
+                value = item.value[0]
+            elif is_orig_id:
+                if not isinstance(value, str):
+                    value = item.value = str(item.value)
+
+            if isinstance(value, int):
+                type_cast = "int"
+            elif isinstance(value, float):
+                type_cast = "float"
+
+            if type_cast is not None:
+                key = TypeCast(type_cast, key)
+
+            if item.op in (FilterOperator.NOT_IN, FilterOperator.IN):
+                values = [Constant(i) for i in item.value]
+                value = AstTuple(values)
+            else:
+                value = Constant(item.value)
+
+            condition = BinaryOperation(op=item.op.value, args=[key, value])
+
+            if where_clause is None:
+                where_clause = condition
+            else:
+                where_clause = BinaryOperation(op="AND", args=[where_clause, condition])
+        return where_clause
diff --git a/mindsdb/integrations/handlers/duckdb_faiss_handler/faiss_index.py b/mindsdb/integrations/handlers/duckdb_faiss_handler/faiss_index.py
index 8aef1808004..45b05451808 100644
--- a/mindsdb/integrations/handlers/duckdb_faiss_handler/faiss_index.py
+++ b/mindsdb/integrations/handlers/duckdb_faiss_handler/faiss_index.py
@@ -1,15 +1,24 @@
 import os
-from typing import Iterable, List
+from typing import Iterable, List, Callable, Optional
 import numpy as np
 import psutil
 from pathlib import Path
 
-import portalocker
+try:
+    import fcntl
+except ImportError:
+    fcntl = None
 
 import faiss  # faiss or faiss-gpu
+
+from mindsdb.utilities import log
+
 from pydantic import BaseModel
 
 
+logger = log.getLogger(__name__)
+
+
 def _normalize_rows(x: np.ndarray) -> np.ndarray:
     norms = np.linalg.norm(x, axis=1, keepdims=True) + 1e-12
     return x / norms
@@ -24,6 +33,54 @@ class FaissParams(BaseModel):
     hnsw_ef_search: int | None = 64
 
 
+def merge_ondisk(trained_index: faiss.Index, shard_fnames: List[str], ivfdata_fname: str, shift_ids=False) -> None:
+    """
+    Modified version of faiss.contrib.ondisk.merge_ondisk. Prevents leaving orphan memory mapped shard files
+
+    Add the contents of the indexes stored in shard_fnames into the index trained_index.
+    The on-disk data is stored in ivfdata_fname
+    """
+    assert not isinstance(trained_index, faiss.IndexIVFPQR), "IndexIVFPQR is not supported as an on disk index."
+    # merge the images into an on-disk index
+    # first load the inverted lists
+    ivfs = []
+    indexes = []
+
+    for fname in shard_fnames:
+        # the IO_FLAG_MMAP is to avoid actually loading the data
+        #  thus the total size of the inverted lists can exceed the available RAM
+        logger.info("read " + fname)
+        index = faiss.read_index(fname, faiss.IO_FLAG_MMAP)
+        index_ivf = faiss.extract_index_ivf(index)
+        ivfs.append(index_ivf.invlists)
+
+        indexes.append(index)
+
+    # construct the output index
+    index = trained_index
+    index_ivf = faiss.extract_index_ivf(index)
+
+    assert index.ntotal == 0, "works only on empty index"
+
+    # prepare the output inverted lists. They will be written to merged_index.ivfdata
+    invlists = faiss.OnDiskInvertedLists(index_ivf.nlist, index_ivf.code_size, ivfdata_fname)
+
+    # merge all the inverted lists
+    ivf_vector = faiss.InvertedListsPtrVector()
+    for ivf in ivfs:
+        ivf_vector.push_back(ivf)
+
+    logger.info("merge %d inverted lists " % ivf_vector.size())
+    ntotal = invlists.merge_from_multiple(ivf_vector.data(), ivf_vector.size(), shift_ids)
+
+    # now replace the inverted lists in the output index
+    index.ntotal = index_ivf.ntotal = ntotal
+    index_ivf.replace_invlists(invlists, True)
+    invlists.this.disown()
+
+    del indexes
+
+
 class FaissIndex:
     def __init__(self, path: str, config: dict):
         self._normalize_vectors = False
@@ -43,7 +100,7 @@ def __init__(self, path: str, config: dict):
         else:
             raise ValueError(f"Unknown metric: {metric}")
 
-        self.path = path
+        self.path = os.path.join(path, "faiss_index")
 
         self._since_ram_checked = 0
 
@@ -51,15 +108,27 @@ def __init__(self, path: str, config: dict):
         self.index_type = "flat"
         self.dim = None
         self.index_fd = None
+        self.lock_required = True
+
+        recover_path = Path(self.path).parent / "recover"
+        if recover_path.exists():
+            # move all files from recover dir that might be left after index failing
+            for item in recover_path.iterdir():
+                if item.is_dir():
+                    continue
+                item.rename(Path(self.path).parent / item.name)
+
         if os.path.exists(self.path):
             self._load_index()
 
     def _lock_index(self):
-        if os.name != "nt":
+        if not self.lock_required:
+            return
+        if os.name != "nt" and fcntl:
             self.index_fd = open(self.path, "rb")
             try:
-                portalocker.lock(self.index_fd, portalocker.LOCK_EX | portalocker.LOCK_NB)
-            except portalocker.exceptions.AlreadyLocked:
+                fcntl.flock(self.index_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except OSError:
                 raise ValueError(f"Index is already used: {self.path}")
 
     def _load_index(self):
@@ -72,22 +141,35 @@ def _load_index(self):
         available_ram = psutil.virtual_memory().available
         if required_ram > _1gb and available_ram < required_ram:
             to_free_gb = round((required_ram - available_ram) / _1gb, 2)
-            raise ValueError(f"Unable load FAISS index into RAM, free up al least : {to_free_gb} Gb")
+            raise ValueError(f"Unable load FAISS index into RAM, free up at least : {to_free_gb} Gb")
+
+        # check ivf_file before loading index and locking it
+        index_merged = Path(self.path).parent / "faiss_index_merged"
+        if index_merged.exists():
+            self.lock_required = False
 
         self._lock_index()
 
         self.index = faiss.read_index(self.path)
         self.dim = self.index.d
 
-        sub_index = faiss.downcast_index(self.index.index)
-        if isinstance(sub_index, faiss.IndexIVFFlat):
-            self.index_type = "ivf"
+        index = self.index
+        if hasattr(index, "index"):
+            index = faiss.downcast_index(index.index)
+        if isinstance(index, faiss.IndexIVFFlat):
+            if index_merged.exists():
+                self.index_type = "ivf_file"
+            else:
+                self.index_type = "ivf"
 
     def close(self):
         if self.index_fd is not None:
             self.index_fd.close()
         self.index = None
 
+    def __del__(self):
+        self.close()
+
     def _build_flat_index(self):
         # TODO option to create hnsw
 
@@ -116,6 +198,9 @@ def _check_ram_usage(self, count_vectors, index_type: str = "flat", m=32, nlist=
                 required = (self.dim * 4 + m * 2 * 4) * count_vectors
             case "ivf":
                 required = (self.dim * 4 + 8) * count_vectors + self.dim * 4 * nlist
+            case "ivf_file":
+                # don't restrict for IVF file
+                required = 0
             case _:
                 raise ValueError(f"Unknown index type: {index_type}")
 
@@ -131,7 +216,7 @@ def _check_ram_usage(self, count_vectors, index_type: str = "flat", m=32, nlist=
     def insert(
         self,
         vectors: Iterable[Iterable[float]],
-        ids: Iterable[float],
+        ids: Iterable[int],
     ) -> None:
         if len(vectors) == 0:
             return
@@ -170,14 +255,18 @@ def dump(self):
 
     def drop(self):
         self.close()
-        if os.path.exists(self.path):
-            os.remove(self.path)
+
+        # remove index files (everything except duckdb)
+        for item in Path(self.path).parent.iterdir():
+            if item.is_dir() or item.name.startswith("duckdb."):
+                continue
+            item.unlink()
 
     def search(
         self,
-        query: Iterable[Iterable[float]],
+        query: Iterable[float],
         limit: int = 10,
-        # allowed_ids: Optional[Sequence[int]] = None,
+        allowed_ids: Optional[Iterable[int]] = None,
     ):
         if self.index is None:
             return [], []
@@ -187,7 +276,16 @@ def search(
         if self._normalize_vectors:
             queries = _normalize_rows(queries)
 
-        ds, ids = self.index.search(queries, limit)
+        params = None
+        if allowed_ids is not None:
+            allowed_ids_array = np.asarray(list(allowed_ids), dtype=np.int64)
+            ids_selector = faiss.IDSelectorArray(
+                len(allowed_ids_array),
+                faiss.swig_ptr(allowed_ids_array),
+            )
+            params = faiss.IVFSearchParameters(sel=ids_selector)
+
+        ds, ids = self.index.search(queries, limit, params=params)
 
         list_id = [i for i in ids[0] if i != -1]
         list_distances = [1 - d for d in ds[0][: len(list_id)]]
@@ -196,31 +294,70 @@ def search(
 
 
 class FaissIVFIndex(FaissIndex):
-    def _dump_vectors(self, index, path, batch_size: int = 10000):
+    def _dump_vectors(self, index, path: Path, batch_size: int = 30000):
         """
-        Save vectors from a Faiss IndexIDMap to disk in batches using numpy memmap.
+        Extract and dump vectors and ids from index. Method is dependent on index type
+        """
+
+        if hasattr(index, "id_map"):
+            ids = faiss.vector_to_array(index.id_map).astype(np.int64, copy=False)
+            inner = index.index
+
+            def get_batch_vectors(start, size):
+                return inner.reconstruct_n(start, size).astype(np.float32, copy=False)
+
+            return self._dump_vectors_to_file(ids, path, index.ntotal, batch_size, get_batch_vectors)
+        else:
+            invlists = index.invlists
+
+            index.set_direct_map_type(faiss.DirectMap.Hashtable)
 
-        - Writes the one memmap for ids and batches for vectors
+            ids_list = []
+            for list_no in range(index.nlist):
+                list_size = invlists.list_size(list_no)
+                if list_size == 0:
+                    continue
 
-        :param  index: Faiss IndexIDMap
-        :param  path: Output directory where batch files will be written
-        :param  batch_size: Number of vectors per batch file
+                # Get IDs stored in this inverted list
+                id_array = faiss.rev_swig_ptr(invlists.get_ids(list_no), list_size)
+                ids_list.append(id_array)
+
+            ids = np.hstack(ids_list).astype(np.int64)
+
+            # to train index first batches will be used. shuffle ids to prevent using the same lists
+            # TODO shuffle only part of data?
+            np.random.shuffle(ids)
+
+            def get_batch_vectors(start, size):
+                ids_batch = ids[start : start + size]
+                return index.reconstruct_batch(ids_batch).astype(np.float32, copy=False)
+
+            return self._dump_vectors_to_file(ids, path, index.ntotal, batch_size, get_batch_vectors)
+
+    def _dump_vectors_to_file(
+        self,
+        ids: np.ndarray,
+        path: Path,
+        ntotal: int,
+        batch_size: int,
+        get_batch_content: Callable[[int, int], np.ndarray],
+    ) -> int:
         """
 
-        if not hasattr(index, "id_map") or not hasattr(index, "index"):
-            raise ValueError("Expected a Faiss IndexIDMap-like object with 'id_map' and 'index' attributes")
+        Write ids and vectors to memmap files in batches.
 
-        ntotal = index.ntotal
+        :param ids: vector IDs in the same order as vectors will be dumped.
+        :param path: directory to store dumps.
+        :param ntotal: total number of vectors.
+        :param batch_size: number of vectors per batch file.
+        :param get_batch_content: function to get a batch content
 
-        ids = faiss.vector_to_array(index.id_map).astype(np.int64, copy=False)
+        """
 
         # Write all ids once to a single memmap file
         ids_path = path / "ids.mmap"
         mmap_ids = np.memmap(ids_path, dtype=np.int64, mode="w+", shape=(ntotal,))
         mmap_ids[:] = ids
-        del mmap_ids  # flush
-
-        inner = index.index
 
         batch_num = 0
         while True:
@@ -233,8 +370,7 @@ def _dump_vectors(self, index, path, batch_size: int = 10000):
             ntotal -= size
             batch_num += 1
 
-            # Reconstruct a contiguous block when possible
-            vecs = inner.reconstruct_n(start, size).astype(np.float32, copy=False)
+            vecs = get_batch_content(start, size)
 
             vecs_path = path / f"batch_{batch_num:05d}_vecs.mmap"
 
@@ -244,40 +380,18 @@ def _dump_vectors(self, index, path, batch_size: int = 10000):
             mmap_vecs.flush()
             del mmap_vecs
 
+        del mmap_ids
         return batch_num
 
-    def _create_ifv_index_from_dump(self, path, train_count=10000, nlist=1024):
-        """
-        Build an IVF index (wrapped in IndexIDMap) from memmap batches
-        - Reads a single `ids.mmap` and multiple `batch_{i}_vecs.mmap` files from `path`.
-        - Accumulates up to `train_count` vectors to train the IVF quantizer.
-        - Creates IndexIVFFlat and adds all vectors with their ids to it.
-
-        :param path: Directory containing memmap files
-        :param train_count: Number of vectors to use for training
-        :param nlist: number of clusters for IVF
-        """
-
-        # Load ids
-        ids_path = path / "ids.mmap"
-        if not os.path.exists(ids_path):
-            raise FileNotFoundError(f"Missing ids memmap: {ids_path}")
-
-        ids = np.fromfile(ids_path, dtype="int64")
-
-        # Collect vector batch files and sort by batch index
-        vec_files = [f for f in os.listdir(path) if f.startswith("batch_")]
-        if not vec_files:
-            raise FileNotFoundError(f"No vector batch memmaps found in {path}")
-
-        vec_files.sort()
-
+    def _train_ivf(self, dump_path, train_count, nlist):
         # Accumulate training data up to train_count
         train_left = train_count
         train_chunks = []
 
+        vec_files = self._get_dump_vector_files(dump_path)
+
         for fname in vec_files:
-            fpath = path / fname
+            fpath = dump_path / fname
             batch_data = np.fromfile(fpath, dtype="float32")
             rows = int(batch_data.shape[0] / self.dim)
 
@@ -288,20 +402,46 @@ def _create_ifv_index_from_dump(self, path, train_count=10000, nlist=1024):
                 break
 
         train_data = np.vstack(train_chunks)
-
-        # nlist can't be less than train data
-        nlist = min(nlist, len(train_data))
+        train_data = train_data[:train_count, :]
 
         quantizer = faiss.IndexFlat(self.dim, self.metric)
         ivf = faiss.IndexIVFFlat(quantizer, self.dim, nlist, self.metric)
 
         ivf.train(train_data)
-        ivf_id_map = faiss.IndexIDMap(ivf)
+        return ivf
+
+    def _get_dump_vector_files(self, dump_path):
+        # Collect vector batch files and sort by batch index
+        vec_files = [f for f in os.listdir(dump_path) if f.startswith("batch_")]
+        if not vec_files:
+            raise FileNotFoundError(f"No vector batch memmaps found in {dump_path}")
+
+        vec_files.sort()
+        return vec_files
+
+    def _create_ivf_index(self, dump_path, train_count, nlist):
+        """
+        Build an in-memory IVF index
+
+        :param dump_path: Directory containing memmap files
+        :param train_count: Number of vectors to use for training
+        :param nlist: number of clusters for IVF
+        """
+
+        # Load ids
+        ids_path = dump_path / "ids.mmap"
+        if not os.path.exists(ids_path):
+            raise FileNotFoundError(f"Missing ids memmap: {ids_path}")
+        ids = np.fromfile(ids_path, dtype="int64")
+
+        ivf = self._train_ivf(dump_path, nlist=nlist, train_count=train_count)
+
+        vec_files = self._get_dump_vector_files(dump_path)
 
         # load data
         start = 0
         for fname in vec_files:
-            fpath = path / fname
+            fpath = dump_path / fname
 
             batch_data = np.fromfile(fpath, dtype="float32")
             rows = int(batch_data.shape[0] / self.dim)
@@ -309,24 +449,140 @@ def _create_ifv_index_from_dump(self, path, train_count=10000, nlist=1024):
             batch_vectors = batch_data.reshape([rows, self.dim])
 
             ids_batch = np.asarray(ids[start : start + rows])
-            ivf_id_map.add_with_ids(batch_vectors, ids_batch)
+            ivf.add_with_ids(batch_vectors, ids_batch)
             start += rows
 
-        return ivf_id_map
+        # remove dumps
+        for item in dump_path.iterdir():
+            item.unlink()
+
+        return ivf
+
+    def _create_ivf_file_index(self, dump_path, train_count, nlist):
+        """Build an IVF on disk index"""
+
+        index_path = dump_path.parent
+        trained_index = self._train_ivf(dump_path, train_count=train_count, nlist=nlist)
+        # store trained index
+        trained_path = str(index_path / "faiss_index.trained")
+        faiss.write_index(trained_index, trained_path)
+
+        ids_path = dump_path / "ids.mmap"
+        if not os.path.exists(ids_path):
+            raise FileNotFoundError(f"Missing ids memmap: {ids_path}")
+        ids = np.fromfile(ids_path, dtype="int64")
+
+        vec_files = self._get_dump_vector_files(dump_path)
+
+        start = 0
+        block_fnames = []
+        for num, fname in enumerate(vec_files):
+            index = faiss.read_index(trained_path)
+            fpath = dump_path / fname
+
+            batch_data = np.fromfile(fpath, dtype="float32")
+            rows = int(batch_data.shape[0] / self.dim)
+
+            batch_vectors = batch_data.reshape([rows, self.dim])
+
+            ids_batch = np.asarray(ids[start : start + rows])
+            index.add_with_ids(batch_vectors, ids_batch)
+            block_fname = str(index_path / f"faiss_index_block.{num}")
+            block_fnames.append(block_fname)
+            faiss.write_index(index, block_fname)
+            start += rows
+
+        # remove dumps
+        for item in dump_path.iterdir():
+            item.unlink()
+
+        index = faiss.read_index(trained_path)
+
+        merge_ondisk(index, block_fnames, str(index_path / "faiss_index_merged"))
+        os.unlink(trained_path)
+        for block_fname in block_fnames:
+            os.unlink(block_fname)
+
+        return index
+
+    def get_size(self):
+        if self.index is None:
+            return 0
+        else:
+            return self.index.ntotal
+
+    def check_required_disk_space(self, index_type):
+        base_path = Path(self.path).parent
+        available = psutil.disk_usage(str(base_path)).free
+
+        # current size of index
+        index_size = 0
+        for item in base_path.iterdir():
+            if item.is_dir() or not item.name.startswith("faiss_index"):
+                continue
+            index_size += item.stat().st_size
+
+        # k - how more space required than current index size
+        if index_type == "ivf_file":
+            # recovery + dump + shard files
+            k = 3.01
+        else:
+            # recovery + dump
+            k = 2.01
+
+        # k-1 because the current index space will be reused
+        if available < index_size * (k - 1):
+            to_free_gb = round((index_size * (k - 1)) / 1024**3, 2)
+            raise ValueError(f"Unable run indexing FAISS not enough disk space, get free at least : {to_free_gb} Gb")
+
+    def create_index(self, index_type=None, nlist=None, train_count=None):
+        """
+        Create or recreate IVF index
+
+        :param index_type: options are: 'ivf' (in RAM) or 'ivf_file' (on disk)
+        :param nlist: number of inverted lists
+        :param train_count: count of vectors to use for training.
+
+        """
+
+        if index_type is None:
+            if os.name == "nt":
+                index_type = "ivf"
+            else:
+                index_type = "ivf_file"
+
+        elif index_type not in ("ivf", "ivf_file"):
+            raise NotImplementedError("Only ivf or ivf_file indexes are supported")
+
+        if index_type == "ivf_file" and os.name == "nt":
+            raise ValueError("'ivf_file' index is not supported on Windows. Try to use 'ivf' instead")
 
-    def create_index(self, nlist=1024, train_count=10000):
         # index might not fit into RAM, extract data to files
-        dump_path = Path(self.path).parent / "dump"
+        base_path = Path(self.path).parent
+        dump_path = base_path / "dump"
 
         # if self.index_type != 'flat':
         #     raise ValueError('Index was already created')
 
-        if self.index is None:
-            ntotal = 0
+        # check params, apply defaults
+        if nlist is None:
+            nlist = self.config.nlist
+
+        ntotal = self.get_size()
+
+        # faiss shows warning if train count is less than 39 * nlist and recommend to use at least this size for train data
+        nlist_k = 39
+        if train_count is not None:
+            if train_count < nlist * nlist_k:
+                raise ValueError(f"Train_count can't be less than nlist * {nlist_k} (is {nlist * nlist_k})")
         else:
-            ntotal = self.index.ntotal
-        if nlist > ntotal:
-            raise ValueError(f"Not enough data to create: {ntotal}, required at lease {nlist} records")
+            # get 10k if possible but not less than nlist * k
+            train_count = max(nlist * nlist_k, min(ntotal, 10000))
+
+        if train_count > ntotal:
+            raise ValueError(f"Not enough data to create index: {ntotal}, at least {train_count} records are required")
+
+        self.check_required_disk_space(index_type)
 
         dump_path.mkdir(exist_ok=True)
 
@@ -339,14 +595,33 @@ def create_index(self, nlist=1024, train_count=10000):
         # unload flat index from RAM
         self.close()
 
+        # buckup index files
+        recover_path = base_path / "recover"
+        recover_path.mkdir(exist_ok=True)
+        for item in base_path.iterdir():
+            if item.is_dir() or item.name.startswith("duckdb."):
+                continue
+            item.rename(recover_path / item.name)
+
         # create ivf index
-        ivf_index = self._create_ifv_index_from_dump(dump_path, train_count=train_count, nlist=nlist)
+        if index_type == "ivf":
+            ivf_index = self._create_ivf_index(dump_path, train_count=train_count, nlist=nlist)
+            self.lock_required = True
+
+        elif index_type == "ivf_file":
+            ivf_index = self._create_ivf_file_index(dump_path, train_count=train_count, nlist=nlist)
+            self.lock_required = False
+        else:
+            raise ValueError(f"Unknown index type: {index_type}")
 
         self.index = ivf_index
-        self.index_type = "ivf"
+        self.index_type = index_type
         self.dump()
         self._lock_index()
 
-        # remove unused items
-        for item in dump_path.iterdir():
+        # remove unused files
+        dump_path.rmdir()
+
+        for item in recover_path.iterdir():
             item.unlink()
+        recover_path.rmdir()
diff --git a/mindsdb/integrations/handlers/duckdb_faiss_handler/requirements.txt b/mindsdb/integrations/handlers/duckdb_faiss_handler/requirements.txt
index 8a1860f26b2..3dd4dc56e15 100644
--- a/mindsdb/integrations/handlers/duckdb_faiss_handler/requirements.txt
+++ b/mindsdb/integrations/handlers/duckdb_faiss_handler/requirements.txt
@@ -1,2 +1 @@
-faiss-cpu>=1.7.4
-portalocker
+faiss-cpu==1.13.2
diff --git a/mindsdb/integrations/handlers/duckdb_faiss_handler/test_faiss_handler.py b/mindsdb/integrations/handlers/duckdb_faiss_handler/test_faiss_handler.py
index 915d89f64ab..6a2711cfbcb 100644
--- a/mindsdb/integrations/handlers/duckdb_faiss_handler/test_faiss_handler.py
+++ b/mindsdb/integrations/handlers/duckdb_faiss_handler/test_faiss_handler.py
@@ -1,11 +1,12 @@
+import pytest
 from unittest.mock import patch
 
 import pandas as pd
 
-from tests.unit.executor.test_knowledge_base import TestKB as BaseTestKB, set_litellm_embedding
+from tests.unit.executor.test_knowledge_base import TestKB, set_embedding
 
 
-class TestFAISS(BaseTestKB):
+class TestFAISS(TestKB):
     "Run unit tests using FAISS handler as storage"
 
     def _get_storage_table(self, kb_name):
@@ -30,9 +31,16 @@ def _get_storage_table(self, kb_name):
 
         return f"faiss_{kb_name}.kb_faiss"
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_ivf_index(self, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    @pytest.mark.parametrize("index_type", ["ivf", "ivf_file"])
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_ivf_index(self, mock_embedding, index_type):
+        """
+        Run test two times:
+         - make ivf index and then reindex to ivf_file
+         - make ivf_file index and then reindex to ivf
+        """
+
+        set_embedding(mock_embedding)
 
         df = self._get_ral_table()
 
@@ -51,20 +59,24 @@ def test_ivf_index(self, mock_litellm_embedding):
             """
         )
 
-        self.run_sql("CREATE INDEX ON KNOWLEDGE_BASE kb_ral WITH (nlist=10)")
+        for i in range(2):
+            self.run_sql(f"CREATE INDEX ON KNOWLEDGE_BASE kb_ral WITH (nlist=10, type='{index_type}')")
+
+            # search works
+            ret = self.run_sql("select * from kb_ral  where k.content = 'white' limit 1")
+            assert "white" in ret["chunk_content"][0]
 
-        # search works
-        ret = self.run_sql("select * from kb_ral  where k.content = 'white' limit 1")
-        assert "white" in ret["chunk_content"][0]
+            # --  test insert  --
+            self.run_sql("insert into kb_ral (id, english) values (10000, 'magpie')")
+            # search
+            ret = self.run_sql("select * from kb_ral  where k.content = 'magpie' limit 1")
+            assert "magpie" in ret["chunk_content"][0]
 
-        # --  test insert  --
-        self.run_sql("insert into kb_ral (id, english) values (10000, 'magpie')")
-        # search
-        ret = self.run_sql("select * from kb_ral  where k.content = 'magpie' limit 1")
-        assert "magpie" in ret["chunk_content"][0]
+            # --  test delete  --
+            self.run_sql("delete from kb_ral where id=10000")
+            # search
+            ret = self.run_sql("select * from kb_ral  where k.content = 'magpie' limit 1")
+            assert len(ret) == 0 or "magpie" not in ret["chunk_content"][0]
 
-        # --  test delete  --
-        self.run_sql("delete from kb_ral where id=10000")
-        # search
-        ret = self.run_sql("select * from kb_ral  where k.content = 'magpie' limit 1")
-        assert len(ret) == 0 or "magpie" not in ret["chunk_content"][0]
+            # toggle index type
+            index_type = "ivf_file" if index_type == "ivf" else "ivf"
diff --git a/mindsdb/integrations/handlers/duckdb_handler/README.md b/mindsdb/integrations/handlers/duckdb_handler/README.md
index 54c1040a42c..5fa9125b940 100644
--- a/mindsdb/integrations/handlers/duckdb_handler/README.md
+++ b/mindsdb/integrations/handlers/duckdb_handler/README.md
@@ -1,41 +1,62 @@
-# DuckDB Handler
+# DuckDB Handler  
 This is the implementation of the DuckDB handler for MindsDB.
 
 ## DuckDB
 DuckDB is an open-source analytical database system. DuckDB is designed for fast execution of analytical queries.
-There are no external dependencies and the DBMS runs completly embedded within a host process, similar to SQLite.
+There are no external dependencies, and the DBMS runs completely embedded within a host process, similar to SQLite.
 DuckDB provides a rich SQL dialect with support for complex queries with transactional guarantees (ACID).
 
-## Implementation
-This handler was implemented using the `duckdb` python client library.
+## Implementation  
+This handler was implemented using the `duckdb` Python client library.
 
 ### DuckDB version
-The DuckDB handler is currently using the `0.7.1.dev187` pre-relase version of the python client library. In case of issues, make sure your DuckDB database is compatible with this version. See the DuckDB handler [requirements.txt](requirements.txt) for details.
-
+The DuckDB handler is currently using the `1.1.3` release version of the Python client library. In case of issues, make sure your DuckDB or MotherDuck database is compatible with this version. See the DuckDB handler [requirements.txt](requirements.txt) for details.
 
 The required arguments to establish a connection are:
 
-* `database`: the name of the DuckDB database file. May also be set to `:memory:`, which will create an in-memory database.
+* `database`: the name of the DuckDB or MotherDuck database file.
+  - Set to `:memory:` to create an in-memory database.
+  - For MotherDuck, specify the database and motherduck_token.
 
-The optional arguments are:
+Additional optional arguments include:
 
+* `motherduck_token`: a token to authenticate with MotherDuck.
 * `read_only`: a flag that specifies if the connection should be made in read-only mode.
-This is required if multiple processes want to access the same database file at the same time.
-
+  - This is required if multiple processes want to access the same database file simultaneously.
 
 ## Usage
-In order to make use of this handler and connect to a DuckDB database in MindsDB, the following syntax can be used:
+To connect to a DuckDB or MotherDuck database in MindsDB, the following syntax can be used:
 
+### DuckDB Example
 ```sql
 CREATE DATABASE duckdb_datasource
 WITH
 engine='duckdb',
 parameters={
-    "database":"db.duckdb"
+    "database": "db.duckdb"
 };
 ```
 
-Now, you can use this established connection to query your database as follows:
+### MotherDuck Example
+```sql
+CREATE DATABASE md_datasource
+WITH  
+engine='duckdb',
+parameters={  
+    "database": "sample_data",
+    "motherduck_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9."
+};
+```
+
+Once the connection is established, you can query the database:
+
 ```sql
 SELECT * FROM duckdb_datasource.my_table;
-```
\ No newline at end of file
+```
+
+For MotherDuck:
+```sql
+SELECT * FROM md_datasource.movies;
+```
+
+By leveraging these features, MindsDB provides powerful integrations with DuckDB and MotherDuck for scalable analytics.
\ No newline at end of file
diff --git a/mindsdb/integrations/handlers/duckdb_handler/connection_args.py b/mindsdb/integrations/handlers/duckdb_handler/connection_args.py
index e5a372f9e88..4d9591e5eb6 100644
--- a/mindsdb/integrations/handlers/duckdb_handler/connection_args.py
+++ b/mindsdb/integrations/handlers/duckdb_handler/connection_args.py
@@ -2,16 +2,26 @@
 
 from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
 
-
 connection_args = OrderedDict(
     database={
-        'type': ARG_TYPE.STR,
-        'description': 'The database file to read and write from. The special value :memory: (default) can be used to create an in-memory database.',
+        "type": ARG_TYPE.STR,
+        "description": (
+            "The database file to read and write from. The special value :memory: (default) "
+            "can be used to create an in-memory database."
+        ),
+    },
+    motherduck_token={
+        "type": ARG_TYPE.STR,
+        "description": "Motherduck access token if want to connect motherduck database.",
     },
     read_only={
-        'type': ARG_TYPE.BOOL,
-        'description': 'A flag that specifies if the connection should be made in read-only mode.',
+        "type": ARG_TYPE.BOOL,
+        "description": ("A flag that specifies if the connection should be made in read-only mode."),
     },
 )
 
-connection_args_example = OrderedDict(database='db.duckdb', read_only=True)
+connection_args_example = OrderedDict(
+    database="sample_data",
+    read_only=True,
+    motherduck_token="ey...enKoT.SsEcCa......",
+)
diff --git a/mindsdb/integrations/handlers/duckdb_handler/duckdb_handler.py b/mindsdb/integrations/handlers/duckdb_handler/duckdb_handler.py
index 7ae5423859c..bc407ef0575 100644
--- a/mindsdb/integrations/handlers/duckdb_handler/duckdb_handler.py
+++ b/mindsdb/integrations/handlers/duckdb_handler/duckdb_handler.py
@@ -19,14 +19,14 @@
 class DuckDBHandler(DatabaseHandler):
     """This handler handles connection and execution of the DuckDB statements."""
 
-    name = 'duckdb'
+    name = "duckdb"
 
     def __init__(self, name: str, **kwargs):
         super().__init__(name)
         self.parser = parse_sql
-        self.dialect = 'postgresql'
-        self.connection_data = kwargs.get('connection_data')
-        self.renderer = SqlalchemyRender('postgres')
+        self.dialect = "postgresql"
+        self.connection_data = kwargs.get("connection_data")
+        self.renderer = SqlalchemyRender("postgres")
 
         self.connection = None
         self.is_connected = False
@@ -44,10 +44,17 @@ def connect(self) -> DuckDBPyConnection:
 
         if self.is_connected is True:
             return self.connection
+        motherduck_token = self.connection_data.get("motherduck_token")
+        if motherduck_token:
+            database = (
+                f"md:{self.connection_data.get('database')}?motherduck_token={motherduck_token}&attach_mode=single"
+            )
+        else:
+            database = self.connection_data.get("database")
 
         args = {
-            'database': self.connection_data.get('database'),
-            'read_only': self.connection_data.get('read_only'),
+            "database": database,
+            "read_only": self.connection_data.get("read_only"),
         }
 
         self.connection = duckdb.connect(**args)
@@ -78,9 +85,7 @@ def check_connection(self) -> StatusResponse:
             self.connect()
             response.success = True
         except Exception as e:
-            logger.error(
-                f'Error connecting to DuckDB {self.connection_data["database"]}, {e}!'
-            )
+            logger.error(f"Error connecting to DuckDB {self.connection_data['database']}, {e}!")
             response.error_message = str(e)
         finally:
             if response.success is True and need_to_close:
@@ -111,17 +116,13 @@ def native_query(self, query: str) -> Response:
             if result:
                 response = Response(
                     RESPONSE_TYPE.TABLE,
-                    data_frame=pd.DataFrame(
-                        result, columns=[x[0] for x in cursor.description]
-                    ),
+                    data_frame=pd.DataFrame(result, columns=[x[0] for x in cursor.description]),
                 )
             else:
                 connection.commit()
                 response = Response(RESPONSE_TYPE.OK)
         except Exception as e:
-            logger.error(
-                f'Error running query: {query} on {self.connection_data["database"]}!'
-            )
+            logger.error(f"Error running query: {query} on {self.connection_data['database']}!")
             response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
 
         cursor.close()
@@ -150,10 +151,10 @@ def get_tables(self) -> Response:
             Response: Names of the tables in the database.
         """
 
-        q = 'SHOW TABLES;'
+        q = "SHOW TABLES;"
         result = self.native_query(q)
         df = result.data_frame
-        result.data_frame = df.rename(columns={df.columns[0]: 'table_name'})
+        result.data_frame = df.rename(columns={df.columns[0]: "table_name"})
         return result
 
     def get_columns(self, table_name: str) -> Response:
@@ -166,5 +167,5 @@ def get_columns(self, table_name: str) -> Response:
             Response: Details of the table.
         """
 
-        query = f'DESCRIBE {table_name};'
+        query = f"DESCRIBE {table_name};"
         return self.native_query(query)
diff --git a/mindsdb/integrations/handlers/dummy_data_handler/dummy_data_handler.py b/mindsdb/integrations/handlers/dummy_data_handler/dummy_data_handler.py
index ec205cb9362..6bac43a3e0f 100644
--- a/mindsdb/integrations/handlers/dummy_data_handler/dummy_data_handler.py
+++ b/mindsdb/integrations/handlers/dummy_data_handler/dummy_data_handler.py
@@ -84,7 +84,7 @@ def get_tables(self) -> HandlerResponse:
         q = "SHOW TABLES;"
         result = self.native_query(q)
         df = result.data_frame
-        result.data_frame = df.rename(columns={df.columns[0]: "table_name"})
+        result._data = df.rename(columns={df.columns[0]: "table_name"})
         return result
 
     def get_columns(self, table_name: str) -> HandlerResponse:
diff --git a/mindsdb/integrations/handlers/elasticsearch_handler/README.md b/mindsdb/integrations/handlers/elasticsearch_handler/README.md
index b672ad22b99..da294c761cd 100644
--- a/mindsdb/integrations/handlers/elasticsearch_handler/README.md
+++ b/mindsdb/integrations/handlers/elasticsearch_handler/README.md
@@ -1,118 +1,130 @@
 ---
-title: ElasticSearch
-sidebarTitle: ElasticSearch
+title: Elasticsearch
+sidebarTitle: Elasticsearch
 ---
 
-This documentation describes the integration of MindsDB with [ElasticSearch](https://www.elastic.co/), a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents..
-The integration allows MindsDB to access data from ElasticSearch and enhance ElasticSearch with AI capabilities.
+This documentation describes the integration of MindsDB with [Elasticsearch](https://www.elastic.co/elasticsearch/), a distributed search and analytics engine.
+The integration allows MindsDB to access data stored in Elasticsearch indices and enhance Elasticsearch with AI capabilities.
+
+## Architecture
+
+This handler uses a **SQL-first architecture** with automatic fallback:
+
+1. **Primary**: Elasticsearch SQL API for maximum performance and compatibility
+2. **Fallback**: Search API for array-containing indexes with automatic array-to-JSON conversion
+3. **Security**: SSL/TLS support with certificate validation
+4. **Efficiency**: Memory-efficient pagination for large datasets
+
+The handler automatically detects when SQL queries encounter array fields and seamlessly falls back to the Search API, converting arrays to JSON strings for SQL compatibility. This approach provides the best performance while handling all Elasticsearch data types.
 
 ## Prerequisites
 
 Before proceeding, ensure the following prerequisites are met:
 
 1. Install MindsDB locally via [Docker](https://docs.mindsdb.com/setup/self-hosted/docker) or [Docker Desktop](https://docs.mindsdb.com/setup/self-hosted/docker-desktop).
-2. To connect ElasticSearch to MindsDB, install the required dependencies following [this instruction](/setup/self-hosted/docker#install-dependencies).
-3. Install or ensure access to ElasticSearch.
+2. To connect Elasticsearch to MindsDB, install the required dependencies following [this instruction](https://docs.mindsdb.com/setup/self-hosted/docker#install-dependencies).
+3. **If installing from source**: Python 3.11 or 3.12 is recommended. Install with: `pip install -e '.[elasticsearch]'`
 
 ## Connection
 
-Establish a connection to ElasticSearch from MindsDB by executing the following SQL command and providing its [handler name](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/elasticsearch_handler) as an engine.
+Establish a connection to your Elasticsearch cluster from MindsDB by executing the following SQL command:
 
 ```sql
-CREATE DATABASE elasticsearch_datasource
+CREATE DATABASE elasticsearch_conn
 WITH ENGINE = 'elasticsearch',
-PARAMETERS={
-   'cloud_id': 'xyz',                               -- optional, if hosts are provided
-   'hosts': 'https://xyz.xyz.gcp.cloud.es.io:123',  -- optional, if cloud_id is provided
-   'api_key': 'xyz',                                -- optional, if user and password are provided
-   'user': 'elastic',                               -- optional, if api_key is provided
-   'password': 'xyz'                                -- optional, if api_key is provided
+PARAMETERS = {
+    "hosts": "localhost:9200",
+    "user": "elastic", 
+    "password": "changeme"
 };
 ```
 
-The connection parameters include the following:
-
-* `cloud_id`: The Cloud ID provided with the ElasticSearch deployment. Required only when `hosts` is not provided.
-* `hosts`: The ElasticSearch endpoint provided with the ElasticSearch deployment. Required only when `cloud_id` is not provided.
-* `api_key`: The API key that you generated for the ElasticSearch deployment. Required only when `user` and `password` are not provided.
-* `user` and `password`: The user and password used to authenticate. Required only when `api_key` is not provided.
+Required connection parameters include the following:
 
-<Tip>
-If you want to connect to the local instance of ElasticSearch, use the below statement:
-
-```sql
-CREATE DATABASE elasticsearch_datasource
-WITH ENGINE = 'elasticsearch',
-PARAMETERS = {
-   "hosts": "127.0.0.1:9200",
-   "user": "user",
-   "password": "password"
-};
-```
+* `hosts`: The Elasticsearch host(s) in format "host:port". For multiple hosts, use comma separation like "host1:port1,host2:port2".
 
-Required connection parameters include the following (at least one of these parameters should be provided):
+Optional connection parameters include the following:
 
-* `hosts`: The IP address and port where ElasticSearch is deployed.
-* `user`: The user used to autheticate access.
-* `password`: The password used to autheticate access.
-</Tip>
+* `user`: The username for Elasticsearch authentication.
+* `password`: The password for Elasticsearch authentication.
+* `api_key`: API key for authentication (alternative to user/password).
+* `cloud_id`: Elastic Cloud deployment ID for hosted Elasticsearch.
+* `ca_certs`: Path to CA certificate file for SSL verification.
+* `client_cert`: Path to client certificate file for SSL authentication.
+* `client_key`: Path to client private key file for SSL authentication.
+* `verify_certs`: Boolean to enable/disable SSL certificate verification (default: true).
+* `timeout`: Request timeout in seconds.
 
 ## Usage
 
+The following usage examples utilize the connection to Elasticsearch made via the `CREATE DATABASE` statement and named `elasticsearch_conn`.
+
 Retrieve data from a specified index by providing the integration name and index name:
 
 ```sql
 SELECT *
-FROM elasticsearch_datasource.my_index
+FROM elasticsearch_conn.products
 LIMIT 10;
 ```
 
-<Note>
-The above examples utilize `elasticsearch_datasource` as the datasource name, which is defined in the `CREATE DATABASE` command.
-</Note>
+Query with filtering and aggregation:
+
+```sql
+SELECT category, COUNT(*) as product_count, AVG(price) as avg_price
+FROM elasticsearch_conn.products 
+WHERE price > 100
+GROUP BY category
+ORDER BY product_count DESC;
+```
+
+Run queries with array fields (automatically converted to JSON strings):
+
+```sql
+SELECT product_name, tags, categories 
+FROM elasticsearch_conn.products 
+WHERE product_id = '12345';
+```
 
 <Tip>
-At the moment, the Elasticsearch SQL API has certain limitations that have an impact on the queries that can be issued via MindsDB. The most notable of these limitations are listed below:
-1. Only `SELECT` queries are supported at the moment.
-2. Array fields are not supported.
-3. Nested fields cannot be queried directly. However, they can be accessed using the `.` operator.
+**Array Field Support**
 
-For a detailed guide on the limitations of the Elasticsearch SQL API, refer to the [official documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/sql-limitations.html).
+The Elasticsearch handler automatically detects and converts array fields to JSON strings for SQL compatibility. This prevents "Arrays not supported" errors while preserving the original data structure.
 </Tip>
 
-## Troubleshooting Guide
+## Troubleshooting
 
 <Warning>
 `Database Connection Error`
 
-* **Symptoms**: Failure to connect MindsDB with the Elasticsearch server.
+* **Symptoms**: Failure to connect MindsDB with the Elasticsearch cluster.
 * **Checklist**:
-    1. Make sure the Elasticsearch server is active.
-    2. Confirm that server, cloud ID and credentials are correct.
+    1. Make sure the Elasticsearch cluster is active and accessible.
+    2. Confirm that host, port, user, and password are correct. Try a direct Elasticsearch connection.
     3. Ensure a stable network between MindsDB and Elasticsearch.
+    4. Check if authentication is required and credentials are valid.
 </Warning>
 
 <Warning>
-`Transport Error` or `Request Error`
+`Arrays Not Supported Error`
 
-* **Symptoms**: Errors related to the issuing of unsupported queries to Elasticsearch.
-* **Checklist**:
-    1. Ensure the query is a `SELECT` query.
-    2. Avoid querying array fields.
-    3. Access nested fields using the `.` operator.
-    4. Refer to the [official documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/sql-limitations.html) for more information if needed.
+* **Symptoms**: SQL queries failing with "Arrays are not supported" message.
+* **Solution**: This is automatically handled by the integration. Array fields are converted to JSON strings for SQL compatibility.
+* **Note**: If you still encounter this error, the handler will automatically fall back to the Search API.
 </Warning>
 
 <Warning>
-`SQL statement cannot be parsed by mindsdb_sql`
-
-* **Symptoms**: SQL queries failing or not recognizing index names containing special characters.
-* **Checklist**:
-    1. Ensure table names with special characters are enclosed in backticks.
-    2. Examples:
-        * Incorrect: SELECT * FROM integration.travel-data
-        * Incorrect: SELECT * FROM integration.'travel-data'
-        * Correct: SELECT * FROM integration.\`travel-data\`
+`SHOW TABLES returns empty or fails`
+
+* **Symptoms**: `SHOW TABLES FROM elasticsearch_conn` returns no results or fails.
+* **Solution**: Use the information_schema alternative:
+    ```sql
+    SELECT table_name FROM information_schema.tables 
+    WHERE table_schema = 'elasticsearch_conn';
+    ```
 </Warning>
 
-This [troubleshooting guide](https://www.elastic.co/guide/en/elasticsearch/reference/current/troubleshooting.html) provided by Elasticsearch might also be helpful.
+## Limitations
+
+* **JOINs**: Not supported due to Elasticsearch architecture limitations.
+* **Complex Subqueries**: Limited by Elasticsearch's SQL capabilities.
+* **Real-time Data**: Elasticsearch has near-real-time search characteristics due to refresh intervals.
\ No newline at end of file
diff --git a/mindsdb/integrations/handlers/elasticsearch_handler/__about__.py b/mindsdb/integrations/handlers/elasticsearch_handler/__about__.py
index 38a6c79dce6..9fa6bf695bc 100644
--- a/mindsdb/integrations/handlers/elasticsearch_handler/__about__.py
+++ b/mindsdb/integrations/handlers/elasticsearch_handler/__about__.py
@@ -1,8 +1,8 @@
 __title__ = "MindsDB Elasticsearch handler"
 __package_name__ = "mindsdb_elasticsearch_handler"
-__version__ = "0.0.1"
-__description__ = "MindsDB handler for Elasticsearch"
-__author__ = "Minura Punchihewa"
+__version__ = "0.1.0"
+__description__ = "MindsDB handler for Elasticsearch with SQL-first query execution"
+__author__ = "MindsDB Inc"
 __github__ = "https://github.com/mindsdb/mindsdb"
 __pypi__ = "https://pypi.org/project/mindsdb/"
 __license__ = "MIT"
diff --git a/mindsdb/integrations/handlers/elasticsearch_handler/connection_args.py b/mindsdb/integrations/handlers/elasticsearch_handler/connection_args.py
index 9857096337b..358051e4fc4 100644
--- a/mindsdb/integrations/handlers/elasticsearch_handler/connection_args.py
+++ b/mindsdb/integrations/handlers/elasticsearch_handler/connection_args.py
@@ -29,6 +29,26 @@
         "description": "The API key for authentication with the Elasticsearch server.",
         "secret": True,
     },
+    ca_certs={
+        "type": ARG_TYPE.STR,
+        "description": "Path to CA certificate file for SSL verification.",
+    },
+    client_cert={
+        "type": ARG_TYPE.STR,
+        "description": "Path to client certificate file for SSL authentication.",
+    },
+    client_key={
+        "type": ARG_TYPE.STR,
+        "description": "Path to client private key file for SSL authentication.",
+    },
+    verify_certs={
+        "type": ARG_TYPE.BOOL,
+        "description": "Whether to verify SSL certificates. Default: true",
+    },
+    timeout={
+        "type": ARG_TYPE.INT,
+        "description": "Request timeout in seconds. Default: 30",
+    },
 )
 
 connection_args_example = OrderedDict(
diff --git a/mindsdb/integrations/handlers/elasticsearch_handler/elasticsearch_handler.py b/mindsdb/integrations/handlers/elasticsearch_handler/elasticsearch_handler.py
index 3c7f2be6eb4..84273799b82 100644
--- a/mindsdb/integrations/handlers/elasticsearch_handler/elasticsearch_handler.py
+++ b/mindsdb/integrations/handlers/elasticsearch_handler/elasticsearch_handler.py
@@ -1,4 +1,5 @@
-from typing import Text, Dict, Optional
+from typing import Text, Dict, Optional, List, Any
+import json
 
 from elasticsearch import Elasticsearch
 from elasticsearch.exceptions import (
@@ -7,11 +8,19 @@
     TransportError,
     RequestError,
 )
+
+# ApiError is only available in Elasticsearch 8+
+try:
+    from elasticsearch.exceptions import ApiError
+except ImportError:
+    ApiError = Exception  # Fallback for ES 7.x compatibility
+
+# ESDialect: SQLAlchemy dialect for Elasticsearch, enables SQL query rendering
+from es.elastic.sqlalchemy import ESDialect
 from pandas import DataFrame
 from mindsdb_sql_parser.ast.base import ASTNode
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
-
-from mindsdb.integrations.libs.base import DatabaseHandler
+from mindsdb.integrations.libs.base import MetaDatabaseHandler
 from mindsdb.integrations.libs.response import (
     HandlerResponse as Response,
     HandlerStatusResponse as StatusResponse,
@@ -23,28 +32,37 @@
 logger = log.getLogger(__name__)
 
 
-class ElasticsearchHandler(DatabaseHandler):
+class ElasticsearchHandler(MetaDatabaseHandler):
     """
-    This handler handles the connection and execution of SQL statements on Elasticsearch.
+    This handler handles the connection and execution of SQL statements on Elasticsearch
+    using a SQL-first architecture with automatic fallback capabilities.
+
+    Features:
+        - SQL-first query execution with automatic Search API fallback
+        - Intelligent array field detection and JSON conversion
+        - SSL/TLS security configuration support
+        - Memory-efficient large dataset handling with pagination
+        - Comprehensive error handling and recovery mechanisms
     """
 
     name = "elasticsearch"
 
     def __init__(self, name: Text, connection_data: Optional[Dict], **kwargs) -> None:
         """
-        Initializes the handler.
+        Initializes the Elasticsearch handler with SQL-first query execution.
 
         Args:
             name (Text): The name of the handler instance.
-            connection_data (Dict): The connection data required to connect to the AWS (S3) account.
-            kwargs: Arbitrary keyword arguments.
+            connection_data (Dict): The connection data required to connect to the Elasticsearch cluster.
+                Should include hosts/cloud_id and authentication parameters.
+            **kwargs: Arbitrary keyword arguments.
         """
         super().__init__(name)
-        self.connection_data = connection_data
+        self.connection_data = connection_data or {}
         self.kwargs = kwargs
-
         self.connection = None
         self.is_connected = False
+        self._array_fields_cache: Dict[str, List[str]] = {}
 
     def __del__(self) -> None:
         """
@@ -55,67 +73,96 @@ def __del__(self) -> None:
 
     def connect(self) -> Elasticsearch:
         """
-        Establishes a connection to the Elasticsearch host.
+        Establishes a connection to the Elasticsearch host with security configuration support.
 
-        Raises:
-            ValueError: If the expected connection parameters are not provided.
+        This method supports both on-premises and cloud Elasticsearch deployments with
+        SSL/TLS configuration and authentication options.
 
         Returns:
             elasticsearch.Elasticsearch: A connection object to the Elasticsearch host.
+
+        Raises:
+            ValueError: If the expected connection parameters are not provided.
+            ConnectionError: If unable to establish connection to Elasticsearch.
+            AuthenticationException: If authentication fails.
         """
-        if self.is_connected is True:
+        if self.is_connected:
             return self.connection
 
-        config = {}
-
-        # Mandatory connection parameters.
-        if ("hosts" not in self.connection_data) and ("cloud_id" not in self.connection_data):
-            raise ValueError("Either the hosts or cloud_id parameter should be provided!")
-
-        # Optional/Additional connection parameters.
-        optional_parameters = ["hosts", "cloud_id", "api_key"]
-        for parameter in optional_parameters:
-            if parameter in self.connection_data:
-                if parameter == "hosts":
-                    config["hosts"] = self.connection_data[parameter].split(",")
-                else:
-                    config[parameter] = self.connection_data[parameter]
+        # Validate required parameters
+        if not self.connection_data.get("hosts") and not self.connection_data.get("cloud_id"):
+            raise ValueError("Either 'hosts' or 'cloud_id' parameter must be provided")
 
-        # Ensure that if either user or password is provided, both are provided.
-        if ("user" in self.connection_data) != ("password" in self.connection_data):
-            raise ValueError("Both user and password should be provided if one of them is provided!")
+        config = {}
 
-        if "user" in self.connection_data:
-            config["basic_auth"] = (
-                self.connection_data["user"],
-                self.connection_data["password"],
-            )
+        # Connection parameters
+        if "hosts" in self.connection_data:
+            hosts_str = self.connection_data["hosts"]
+            hosts = hosts_str.split(",")
+
+            # Validate host:port format
+            for host in hosts:
+                host = host.strip()
+                if ":" not in host:
+                    raise ValueError(
+                        f"Invalid host format '{host}'. Expected format: 'host:port' (e.g., 'localhost:9200')"
+                    )
+                # Additional validation: check port is numeric
+                try:
+                    host_part, port_part = host.rsplit(":", 1)
+                    int(port_part)  # Validate port is numeric
+                except ValueError:
+                    raise ValueError(f"Invalid port in host '{host}'. Port must be numeric")
+
+            config["hosts"] = hosts
+        if "cloud_id" in self.connection_data:
+            config["cloud_id"] = self.connection_data["cloud_id"]
+
+        # Authentication - API key takes precedence
+        if "api_key" in self.connection_data:
+            config["api_key"] = self.connection_data["api_key"]
+            # Skip user/password if API key is provided
+        else:
+            # Only check user/password if API key is not provided
+            user = self.connection_data.get("user")
+            password = self.connection_data.get("password")
+            if user and password:
+                config["http_auth"] = (user, password)
+            elif user or password:
+                raise ValueError("Both 'user' and 'password' must be provided together")
+
+        # SSL/TLS configuration (secure by default)
+        config["verify_certs"] = self.connection_data.get("verify_certs", True)
+        if "ca_certs" in self.connection_data:
+            config["ca_certs"] = self.connection_data["ca_certs"]
+        if "client_cert" in self.connection_data:
+            config["client_cert"] = self.connection_data["client_cert"]
+        if "client_key" in self.connection_data:
+            config["client_key"] = self.connection_data["client_key"]
+        if "timeout" in self.connection_data:
+            config["timeout"] = self.connection_data["timeout"]
 
         try:
-            self.connection = Elasticsearch(
-                **config,
-            )
+            self.connection = Elasticsearch(**config)
             self.is_connected = True
             return self.connection
-        except ConnectionError as conn_error:
-            logger.error(f"Connection error when connecting to Elasticsearch: {conn_error}")
-            raise
-        except AuthenticationException as auth_error:
-            logger.error(f"Authentication error when connecting to Elasticsearch: {auth_error}")
+        except (ConnectionError, AuthenticationException) as e:
+            logger.error(f"Connection failed: {e}")
             raise
-        except Exception as unknown_error:
-            logger.error(f"Unknown error when connecting to Elasticsearch: {unknown_error}")
+        except Exception as e:
+            logger.error(f"Unexpected connection error: {e}")
             raise
 
     def disconnect(self) -> None:
         """
         Closes the connection to the Elasticsearch host if it's currently open.
         """
-        if self.is_connected is False:
+        if not self.is_connected:
             return
-
-        self.connection.close()
-        self.is_connected = False
+        try:
+            self.connection.close()
+        finally:
+            self.is_connected = False
 
     def check_connection(self) -> StatusResponse:
         """
@@ -125,81 +172,318 @@ def check_connection(self) -> StatusResponse:
             StatusResponse: An object containing the success status and an error message if an error occurs.
         """
         response = StatusResponse(False)
-        need_to_close = self.is_connected is False
+        need_to_close = not self.is_connected
 
         try:
             connection = self.connect()
-
-            # Execute a simple query to test the connection.
+            # Simple test query
             connection.sql.query(body={"query": "SELECT 1"})
             response.success = True
-        # All exceptions are caught here to ensure that the connection is closed if an error occurs.
         except Exception as error:
-            logger.error(f"Error connecting to Elasticsearch, {error}!")
+            logger.error(f"Connection check failed: {error}")
             response.error_message = str(error)
+            if self.is_connected:
+                self.is_connected = False
 
         if response.success and need_to_close:
             self.disconnect()
 
-        elif not response.success and self.is_connected:
-            self.is_connected = False
-
         return response
 
     def native_query(self, query: Text) -> Response:
         """
-        Executes a native SQL query on the Elasticsearch host and returns the result.
+        Executes a native SQL query on the Elasticsearch host using SQL-first approach.
+
+        This method uses a dual-strategy approach:
+        1. Primary: Uses Elasticsearch SQL API for performance and compatibility
+        2. Fallback: Automatically switches to Search API for array-containing indexes
+        3. Handles pagination and large result sets
 
         Args:
-            query (str): The SQL query to be executed.
+            query (Text): The SQL query to be executed.
 
         Returns:
             Response: A response object containing the result of the query or an error message.
         """
-        need_to_close = self.is_connected is False
-
+        logger.debug(f"Executing query: {query[:100]}...")
+        need_to_close = not self.is_connected
         connection = self.connect()
+
         try:
+            # Primary: Try SQL API first (standard approach)
             response = connection.sql.query(body={"query": query})
             records = response["rows"]
             columns = response["columns"]
 
-            new_records = True
-            while new_records:
+            # Handle pagination for large result sets with safety limit
+            max_pages = 100  # Prevent infinite pagination
+            for _ in range(max_pages):
+                if not response.get("cursor"):
+                    break
+                response = connection.sql.query(body={"query": query, "cursor": response["cursor"]})
+                if not response["rows"]:
+                    break
+                records.extend(response["rows"])
+
+            column_names = [col["name"] for col in columns]
+            if not records:
+                records = [[None] * len(column_names)]
+
+            return Response(RESPONSE_TYPE.TABLE, data_frame=DataFrame(records, columns=column_names))
+
+        except (TransportError, RequestError, ApiError) as e:
+            error_msg = str(e).lower()
+
+            # Intelligent fallback: Check if error is array-related
+            if any(keyword in error_msg for keyword in ["array", "nested", "object"]):
+                logger.debug(f"SQL API failed with array-related error, using Search API fallback: {e}")
                 try:
-                    if response["cursor"]:
-                        response = connection.sql.query(body={"query": query, "cursor": response["cursor"]})
+                    return self._search_api_fallback(query)
+                except Exception as fallback_error:
+                    logger.error(f"Search API fallback also failed: {fallback_error}")
+                    return Response(
+                        RESPONSE_TYPE.ERROR, error_message=f"Both SQL and Search APIs failed: {fallback_error}"
+                    )
+
+            # Handle other SQL API errors
+            logger.error(f"SQL API error: {e}")
+            return Response(RESPONSE_TYPE.ERROR, error_message=str(e))
+
+        except Exception as e:
+            logger.error(f"Unexpected query error: {e}")
+            return Response(RESPONSE_TYPE.ERROR, error_message=str(e))
+
+        finally:
+            if need_to_close:
+                self.disconnect()
+
+    def _search_api_fallback(self, query: str) -> Response:
+        """
+        Search API fallback for array-containing indexes.
 
-                        new_records = response["rows"]
-                        records = records + new_records
-                except KeyError:
-                    new_records = False
+        This method is automatically invoked when SQL API encounters array fields,
+        providing seamless query execution with proper array handling.
 
-            column_names = [column["name"] for column in columns]
-            if not records:
-                null_record = [None] * len(column_names)
-                records = [null_record]
+        Args:
+            query (str): Original SQL query that failed with SQL API
+
+        Returns:
+            Response: Search results converted to tabular format with arrays as JSON strings
+        """
+        # Simple query parsing (only what's needed for Search API)
+        index_name = self._extract_table_name(query)
+        if not index_name:
+            raise ValueError("Could not determine index name from query")
+
+        # Extract LIMIT from query if present
+        limit = self._extract_limit(query)
+        if limit is None:
+            limit = 10000  # Default maximum documents to fetch to prevent memory issues
+
+        # Execute search with pagination
+        scroll_id = None
+        try:
+            batch_size = min(1000, limit)  # Use smaller batch size if limit is small
+            search_body = {
+                "size": batch_size,
+                "query": {"match_all": {}},
+            }
+
+            response = self.connection.search(index=index_name, body=search_body, scroll="5m")
+
+            records = []
+            all_columns = set()
+            scroll_id = response.get("_scroll_id")
+            processed_count = 0
+
+            # Process results in batches with explicit limit
+            max_batches = (limit // batch_size) + 1  # Calculate max batches needed
+            for _ in range(max_batches):
+                hits = response.get("hits", {}).get("hits", [])
+                if not hits:
+                    break
+
+                for hit in hits:
+                    if processed_count >= limit:
+                        break
+
+                    doc = hit.get("_source", {})
+                    if doc:
+                        converted_doc = self._convert_arrays_to_strings(doc)
+                        flattened_doc = self._flatten_document(converted_doc)
+                        if flattened_doc:
+                            records.append(flattened_doc)
+                            all_columns.update(flattened_doc.keys())
+                            processed_count += 1
+
+                # Get next batch if we haven't reached the limit
+                if not scroll_id or processed_count >= limit:
+                    break
+                try:
+                    response = self.connection.scroll(scroll_id=scroll_id, scroll="5m")
+                except Exception:
+                    break
+
+            # Normalize records
+            columns = sorted(all_columns) if all_columns else ["no_data"]
+            normalized_records = []
+
+            for record in records:
+                normalized_records.append([record.get(col) for col in columns])
 
-            response = Response(
-                RESPONSE_TYPE.TABLE,
-                data_frame=DataFrame(records, columns=column_names),
+            if not normalized_records:
+                normalized_records = [[None] * len(columns)]
+
+            return Response(RESPONSE_TYPE.TABLE, data_frame=DataFrame(normalized_records, columns=columns))
+
+        except Exception as e:
+            raise Exception(f"Search API execution failed: {e}")
+        finally:
+            # Clean up scroll - ensures cleanup even if exceptions occur
+            if scroll_id:
+                try:
+                    self.connection.clear_scroll(scroll_id=scroll_id)
+                except Exception:
+                    pass
+
+    def _extract_table_name(self, query: str) -> Optional[str]:
+        """
+        Extracts the table/index name from a SQL query.
+
+        Args:
+            query (str): SQL query string
+
+        Returns:
+            Optional[str]: The extracted table name, or None if not found
+        """
+        import re
+
+        match = re.search(r'FROM\s+([`"]?)([^`"\s]+)\1', query, re.IGNORECASE)
+        return match.group(2) if match else None
+
+    def _extract_limit(self, query: str) -> Optional[int]:
+        """
+        Extracts the LIMIT value from a SQL query.
+
+        Args:
+            query (str): SQL query string
+
+        Returns:
+            Optional[int]: The extracted limit value, or None if not found
+        """
+        import re
+
+        match = re.search(r"LIMIT\s+(\d+)", query, re.IGNORECASE)
+        if match:
+            try:
+                return int(match.group(1))
+            except ValueError:
+                return None
+        return None
+
+    def _detect_array_fields(self, index_name: str) -> List[str]:
+        """
+        Detects array fields in the specified index with caching.
+
+        Args:
+            index_name (str): The name of the index to analyze
+
+        Returns:
+            List[str]: List of field paths that contain arrays
+        """
+        if index_name in self._array_fields_cache:
+            return self._array_fields_cache[index_name]
+
+        array_fields = []
+        try:
+            response = self.connection.search(
+                index=index_name, body={"size": 5, "query": {"match_all": {}}}, _source=True
             )
 
-        except (TransportError, RequestError) as transport_or_request_error:
-            logger.error(f"Error running query: {query} on Elasticsearch, {transport_or_request_error}!")
-            response = Response(RESPONSE_TYPE.ERROR, error_message=str(transport_or_request_error))
-        except Exception as unknown_error:
-            logger.error(f"Unknown error running query: {query} on Elasticsearch, {unknown_error}!")
-            response = Response(RESPONSE_TYPE.ERROR, error_message=str(unknown_error))
+            for hit in response.get("hits", {}).get("hits", []):
+                doc = hit.get("_source", {})
+                array_fields.extend(self._find_arrays_in_doc(doc))
 
-        if need_to_close is True:
-            self.disconnect()
+            array_fields = list(set(array_fields))
 
-        return response
+            # Only cache non-empty results to prevent false negatives
+            if array_fields:
+                self._array_fields_cache[index_name] = array_fields
+
+        except Exception as e:
+            logger.error(f"Array field detection failed for {index_name}: {e}")
+
+        return array_fields
+
+    def _find_arrays_in_doc(self, doc: Any, prefix: str = "") -> List[str]:
+        """
+        Recursively finds array fields in a document.
+
+        Args:
+            doc (Any): The document to analyze
+            prefix (str): Current field path prefix for nested fields
+
+        Returns:
+            List[str]: List of field paths containing arrays
+        """
+        arrays = []
+        if isinstance(doc, dict):
+            for key, value in doc.items():
+                field_path = f"{prefix}.{key}" if prefix else key
+                if isinstance(value, list):
+                    arrays.append(field_path)
+                elif isinstance(value, dict):
+                    arrays.extend(self._find_arrays_in_doc(value, field_path))
+        return arrays
+
+    def _convert_arrays_to_strings(self, obj: Any) -> Any:
+        """
+        Converts arrays to JSON strings for SQL compatibility.
+
+        Args:
+            obj (Any): Object that may contain arrays
+
+        Returns:
+            Any: Object with arrays converted to JSON strings
+        """
+        if isinstance(obj, list):
+            try:
+                return json.dumps(obj, ensure_ascii=False, default=str)
+            except (TypeError, ValueError):
+                return str(obj)
+        elif isinstance(obj, dict):
+            return {k: self._convert_arrays_to_strings(v) for k, v in obj.items()}
+        return obj
+
+    def _flatten_document(self, doc: Dict, prefix: str = "", max_depth: int = 10, _depth: int = 0) -> Dict:
+        """
+        Flattens nested documents with depth protection to prevent stack overflow.
+
+        Args:
+            doc (Dict): Document to flatten
+            prefix (str): Field path prefix for nested fields
+            max_depth (int): Maximum recursion depth to prevent stack overflow
+            _depth (int): Current recursion depth (internal use)
+
+        Returns:
+            Dict: Flattened document with dot-notation field names
+        """
+        if not isinstance(doc, dict) or _depth >= max_depth:
+            return {prefix or "value": str(doc)}
+
+        flattened = {}
+        for key, value in doc.items():
+            field_path = f"{prefix}.{key}" if prefix else key
+            if isinstance(value, dict):
+                flattened.update(self._flatten_document(value, field_path, max_depth, _depth + 1))
+            else:
+                flattened[field_path] = value
+
+        return flattened
 
     def query(self, query: ASTNode) -> Response:
         """
-        Executes a SQL query represented by an ASTNode on the Elasticsearch host and retrieves the data.
+        Executes a SQL query represented by an ASTNode on the Elasticsearch host.
 
         Args:
             query (ASTNode): An ASTNode representing the SQL query to be executed.
@@ -207,12 +491,14 @@ def query(self, query: ASTNode) -> Response:
         Returns:
             Response: The response from the `native_query` method, containing the result of the SQL query execution.
         """
-        # TODO: Add support for other query types.
-        # Use postgresql dialect for SQL rendering - Elasticsearch SQL is ANSI-compatible
-        renderer = SqlalchemyRender("postgresql")
-        query_str = renderer.get_string(query, with_failback=True)
-        logger.debug(f"Executing SQL query: {query_str}")
-        return self.native_query(query_str)
+        try:
+            renderer = SqlalchemyRender(ESDialect)
+            query_str = renderer.get_string(query, with_failback=True)
+            logger.debug(f"Executing AST query as SQL: {query_str}")
+            return self.native_query(query_str)
+        except Exception as e:
+            logger.error(f"AST query execution failed: {e}")
+            return Response(RESPONSE_TYPE.ERROR, error_message=str(e))
 
     def get_tables(self) -> Response:
         """
@@ -220,19 +506,17 @@ def get_tables(self) -> Response:
 
         Returns:
             Response: A response object containing a list of tables (indexes) in the Elasticsearch host.
+                System indices (starting with '.') are filtered out.
         """
-        query = """
-            SHOW TABLES
-        """
+        query = "SHOW TABLES"
         result = self.native_query(query)
 
-        df = result.data_frame
-
-        # Remove indices that are system indices: These are indices that start with a period.
-        df = df[~df["name"].str.startswith(".")]
-
-        df = df.drop(["catalog", "kind"], axis=1)
-        result.data_frame = df.rename(columns={"name": "table_name", "type": "table_type"})
+        if result.type == RESPONSE_TYPE.TABLE:
+            df = result.data_frame
+            # Filter out system indexes (starting with .)
+            df = df[~df["name"].str.startswith(".")]
+            df = df.drop(["catalog", "kind"], axis=1, errors="ignore")
+            result.data_frame = df.rename(columns={"name": "table_name", "type": "table_type"})
 
         return result
 
@@ -241,24 +525,458 @@ def get_columns(self, table_name: Text) -> Response:
         Retrieves column (field) details for a specified table (index) in the Elasticsearch host.
 
         Args:
-            table_name (str): The name of the table for which to retrieve column information.
+            table_name (Text): The name of the table for which to retrieve column information.
+
+        Returns:
+            Response: A response object containing the column details.
 
         Raises:
             ValueError: If the 'table_name' is not a valid string.
+        """
+        if not table_name or not isinstance(table_name, str):
+            raise ValueError("Table name must be a non-empty string")
+
+        query = f"DESCRIBE {table_name}"
+        result = self.native_query(query)
+
+        if result.type == RESPONSE_TYPE.TABLE:
+            df = result.data_frame
+            df = df.drop("mapping", axis=1, errors="ignore")
+            result.data_frame = df.rename(columns={"column": "COLUMN_NAME", "type": "DATA_TYPE"})
+
+        return result
+
+    def meta_get_column_statistics_for_table(
+        self, table_name: str, column_names: Optional[List[str]] = None
+    ) -> Response:
+        """
+        Retrieves statistics for columns in the specified Elasticsearch index.
+
+        This method uses Elasticsearch aggregations to efficiently gather statistics in a single query:
+        - Numeric fields: min, max (via stats aggregation)
+        - Keyword fields: distinct count (cardinality)
+        - Text fields: distinct count (cardinality on .keyword multi-field)
+        - Date fields: min, max (via stats aggregation, as timestamps)
+        - All fields: null percentage (missing values / total docs)
+        - Object/nested fields: excluded from aggregations, null percentage only
+        - Nested/array fields: treated as text (cardinality on JSON string representation)
+
+        Implementation Details:
+        - Text fields use the .keyword multi-field suffix for aggregations
+        - Object and nested types are skipped for cardinality (not aggregatable)
+        - If aggregations fail (e.g., text field without .keyword), returns schema with NULL values
+        - All statistics gathered in a single Elasticsearch search query for performance
+
+        Args:
+            table_name (str): The name of the index to analyze.
+            column_names (Optional[List[str]]): Specific column names. If None, returns statistics for all columns.
 
         Returns:
-            Response: A response object containing the column details.
+            Response: DataFrame with columns:
+                - TABLE_NAME: Index name
+                - COLUMN_NAME: Field name
+                - DATA_TYPE: Elasticsearch field type
+                - NULL_PERCENTAGE: Percentage of documents missing this field (0.0-100.0)
+                - DISTINCT_VALUES_COUNT: Approximate count of unique values (0 if not aggregatable)
+                - MINIMUM_VALUE: Minimum value (numeric/date fields, None otherwise)
+                - MAXIMUM_VALUE: Maximum value (numeric/date fields, None otherwise)
+
+        Raises:
+            ValueError: If table_name is invalid or column_names not found in index.
+
+        Example:
+            >>> handler.meta_get_column_statistics_for_table('kibana_sample_data_flights')
+            >>> handler.meta_get_column_statistics_for_table('products', ['price', 'quantity'])
         """
         if not table_name or not isinstance(table_name, str):
-            raise ValueError("Invalid table name provided.")
+            raise ValueError("Table name must be a non-empty string")
+
+        logger.debug(f"Getting column statistics for {table_name}, columns: {column_names}")
+        need_to_close = not self.is_connected
+        connection = self.connect()
+
+        try:
+            # Step 1: Get index mapping to determine field types
+            mapping_response = connection.indices.get_mapping(index=table_name)
+
+            # Extract field mappings (handle both single and multi-index responses)
+            if table_name in mapping_response:
+                properties = mapping_response[table_name].get("mappings", {}).get("properties", {})
+            else:
+                # For wildcard or first index in response
+                first_index = list(mapping_response.keys())[0]
+                properties = mapping_response[first_index].get("mappings", {}).get("properties", {})
+
+            if not properties:
+                logger.warning(f"No properties found for index {table_name}")
+                return Response(
+                    RESPONSE_TYPE.TABLE,
+                    data_frame=DataFrame(
+                        columns=[
+                            "TABLE_NAME",
+                            "COLUMN_NAME",
+                            "DATA_TYPE",
+                            "NULL_PERCENTAGE",
+                            "DISTINCT_VALUES_COUNT",
+                            "MINIMUM_VALUE",
+                            "MAXIMUM_VALUE",
+                        ]
+                    ),
+                )
+
+            # Step 2: Flatten nested field mappings and filter by column_names if provided
+            fields_to_analyze = {}
+            self._extract_fields_from_mapping(properties, fields_to_analyze, prefix="")
+
+            if column_names:
+                # Filter to only requested columns
+                filtered_fields = {}
+                for col_name in column_names:
+                    if col_name not in fields_to_analyze:
+                        raise ValueError(f"Column '{col_name}' not found in index '{table_name}'")
+                    filtered_fields[col_name] = fields_to_analyze[col_name]
+                fields_to_analyze = filtered_fields
+
+            # Step 3: Build comprehensive aggregation query
+            aggs = {}
+            for field_name, field_info in fields_to_analyze.items():
+                field_type = field_info.get("type", "object")
+                safe_field_name = field_name.replace(".", "_")
+
+                # Skip object/nested types - they don't support aggregations
+                if field_type in ["object", "nested"]:
+                    continue
+
+                # Determine aggregation field (text fields need .keyword suffix)
+                agg_field = field_name
+                if field_type == "text":
+                    # Check if .keyword multi-field exists in mapping
+                    multi_fields = field_info.get("fields", {})
+                    if "keyword" in multi_fields:
+                        # Text field has .keyword multi-field for aggregations
+                        agg_field = f"{field_name}.keyword"
+                    else:
+                        # Text field without .keyword - skip this field
+                        # (fielddata would need to be enabled, which is not recommended for text fields)
+                        logger.debug(f"Text field '{field_name}' has no .keyword multi-field, skipping")
+                        continue
+
+                # Cardinality aggregation for distinct count
+                aggs[f"{safe_field_name}_cardinality"] = {
+                    "cardinality": {
+                        "field": agg_field,
+                        "precision_threshold": 3000,  # Improves performance on large datasets
+                    }
+                }
+
+                # Missing aggregation for null count
+                aggs[f"{safe_field_name}_missing"] = {"missing": {"field": field_name}}
+
+                # Stats aggregation for numeric and date fields
+                if field_type in [
+                    "long",
+                    "integer",
+                    "short",
+                    "byte",
+                    "double",
+                    "float",
+                    "half_float",
+                    "scaled_float",
+                    "date",
+                ]:
+                    aggs[f"{safe_field_name}_stats"] = {"stats": {"field": field_name}}
+
+            # Step 4: Execute single aggregation query for all statistics
+            search_body = {
+                "size": 0,  # We only need aggregations, not documents
+                "aggs": aggs,
+            }
+
+            logger.debug(f"Executing aggregation query with {len(aggs)} aggregations")
+
+            # Execute aggregation query with error handling for field-specific failures
+            try:
+                agg_response = connection.search(index=table_name, body=search_body)
+            except Exception as search_error:
+                # If aggregation fails (e.g., text field without .keyword), log and retry without problematic aggs
+                error_msg = str(search_error).lower()
+                if "fielddata" in error_msg or "keyword" in error_msg or "text" in error_msg:
+                    logger.warning(f"Aggregation failed, possibly due to text field without fielddata: {search_error}")
+                    # Return basic statistics without aggregations
+                    stats_data = []
+                    for field_name, field_info in fields_to_analyze.items():
+                        stats_data.append(
+                            {
+                                "TABLE_NAME": table_name,
+                                "COLUMN_NAME": field_name,
+                                "DATA_TYPE": field_info.get("type", "object"),
+                                "NULL_PERCENTAGE": None,
+                                "DISTINCT_VALUES_COUNT": None,
+                                "MINIMUM_VALUE": None,
+                                "MAXIMUM_VALUE": None,
+                            }
+                        )
+                    return Response(RESPONSE_TYPE.TABLE, data_frame=DataFrame(stats_data))
+                else:
+                    raise
+
+            # Step 5: Parse aggregation results into statistics
+            # Get total document count for NULL_PERCENTAGE calculation
+            total_docs = agg_response.get("hits", {}).get("total", {})
+            if isinstance(total_docs, dict):
+                total_doc_count = total_docs.get("value", 0)
+            else:
+                total_doc_count = total_docs  # ES 6.x returns int directly
+
+            stats_data = []
+            for field_name, field_info in fields_to_analyze.items():
+                field_type = field_info.get("type", "object")
+                safe_field_name = field_name.replace(".", "_")
+
+                aggregations = agg_response.get("aggregations", {})
+
+                # Extract cardinality (distinct count)
+                cardinality_key = f"{safe_field_name}_cardinality"
+                cardinality_result = aggregations.get(cardinality_key, {})
+                distinct_count = int(cardinality_result.get("value", 0)) if cardinality_result else 0
+
+                # Extract missing count and calculate NULL_PERCENTAGE
+                missing_key = f"{safe_field_name}_missing"
+                missing_result = aggregations.get(missing_key, {})
+                null_count = missing_result.get("doc_count", 0) if missing_result else 0
+                null_percentage = (null_count / total_doc_count * 100.0) if total_doc_count > 0 else 0.0
+
+                # Extract stats for numeric/date fields
+                stats_key = f"{safe_field_name}_stats"
+                stats = aggregations.get(stats_key, {})
+
+                min_val = stats.get("min") if stats else None
+                max_val = stats.get("max") if stats else None
+
+                stats_data.append(
+                    {
+                        "TABLE_NAME": table_name,
+                        "COLUMN_NAME": field_name,
+                        "DATA_TYPE": field_type,
+                        "NULL_PERCENTAGE": null_percentage,
+                        "DISTINCT_VALUES_COUNT": distinct_count,
+                        "MINIMUM_VALUE": min_val,
+                        "MAXIMUM_VALUE": max_val,
+                    }
+                )
+
+            result_df = DataFrame(stats_data)
+            logger.debug(f"Retrieved statistics for {len(stats_data)} fields")
+
+            return Response(RESPONSE_TYPE.TABLE, data_frame=result_df)
+
+        except ValueError:
+            # Re-raise ValueError (e.g., invalid column name) as-is
+            raise
+        except Exception as e:
+            logger.error(f"Failed to get column statistics: {e}")
+            return Response(RESPONSE_TYPE.ERROR, error_message=str(e))
 
-        query = f"""
-            DESCRIBE {table_name}
+        finally:
+            if need_to_close:
+                self.disconnect()
+
+    def _extract_fields_from_mapping(self, properties: Dict, fields: Dict, prefix: str = "") -> None:
         """
+        Recursively extracts field definitions from Elasticsearch mapping.
+
+        This helper method flattens nested object and nested type fields into dot-notation paths.
+
+        Args:
+            properties (Dict): Field properties from mapping
+            fields (Dict): Output dictionary to populate with field definitions
+            prefix (str): Current field path prefix for nested fields
+        """
+        for field_name, field_def in properties.items():
+            full_field_name = f"{prefix}.{field_name}" if prefix else field_name
+            field_type = field_def.get("type")
+
+            if field_type:
+                # Regular field with a type
+                fields[full_field_name] = field_def
+            elif "properties" in field_def:
+                # Nested object - recurse into it
+                self._extract_fields_from_mapping(field_def["properties"], fields, full_field_name)
+            else:
+                # Field without type or properties (treat as object)
+                fields[full_field_name] = {"type": "object"}
+
+    def meta_get_primary_keys(self, table_names: Optional[List[str]] = None) -> Response:
+        """
+        Retrieves the primary keys for the specified Elasticsearch indices.
+
+        In Elasticsearch, the _id field serves as the implicit primary key for each document.
+        This method always returns _id as the primary key for each table.
+
+        Args:
+            table_names (Optional[List[str]]): List of index names. If None, returns primary keys for all tables.
+
+        Returns:
+            Response: DataFrame with columns:
+                - TABLE_NAME: Name of the index
+                - CONSTRAINT_NAME: Name of the primary key constraint
+                - COLUMN_NAME: The column name (_id)
+
+        Example:
+            >>> handler.meta_get_primary_keys(['products', 'orders'])
+            # Returns: TABLE_NAME='products', CONSTRAINT_NAME='PRIMARY', COLUMN_NAME='_id'
+            #          TABLE_NAME='orders', CONSTRAINT_NAME='PRIMARY', COLUMN_NAME='_id'
+        """
+        logger.debug(f"Getting primary keys for tables: {table_names}")
+
+        # If no table names specified, get all tables
+        if not table_names:
+            tables_response = self.get_tables()
+            if tables_response.type == RESPONSE_TYPE.ERROR:
+                return tables_response
+            table_names = tables_response.data_frame["TABLE_NAME"].tolist()
+
+        # Elasticsearch always uses _id as the document identifier (primary key)
+        pk_data = []
+        for table_name in table_names:
+            pk_data.append({"TABLE_NAME": table_name, "CONSTRAINT_NAME": "PRIMARY", "COLUMN_NAME": "_id"})
+
+        return Response(RESPONSE_TYPE.TABLE, data_frame=DataFrame(pk_data))
+
+    def meta_get_foreign_keys(self, table_names: Optional[List[str]] = None) -> Response:
+        """
+        Retrieves foreign keys for the specified Elasticsearch indices.
+
+        Elasticsearch is a NoSQL document store and does not support foreign key constraints.
+        This method always returns an empty DataFrame with the proper structure.
+
+        Args:
+            table_names (Optional[List[str]]): List of index names. If None, applies to all tables.
+
+        Returns:
+            Response: Empty DataFrame with columns:
+                - CHILD_TABLE_NAME: The table containing the foreign key
+                - CHILD_COLUMN_NAME: The column name
+                - PARENT_TABLE_NAME: The referenced table name
+                - PARENT_COLUMN_NAME: The referenced column name
+                - CONSTRAINT_NAME: Foreign key constraint name
+
+        Example:
+            >>> handler.meta_get_foreign_keys(['products'])
+            # Returns: Empty DataFrame (NoSQL has no foreign keys)
+        """
+        logger.debug(f"Getting foreign keys for tables: {table_names} (NoSQL - will return empty)")
+
+        # Elasticsearch is NoSQL and doesn't have foreign key constraints
+        return Response(
+            RESPONSE_TYPE.TABLE,
+            data_frame=DataFrame(
+                columns=[
+                    "CHILD_TABLE_NAME",
+                    "CHILD_COLUMN_NAME",
+                    "PARENT_TABLE_NAME",
+                    "PARENT_COLUMN_NAME",
+                    "CONSTRAINT_NAME",
+                ]
+            ),
+        )
+
+    def meta_get_tables(self, table_names: Optional[List[str]] = None) -> Response:
+        """
+        Retrieves metadata for tables (indices) in the Elasticsearch host.
+
+        Args:
+            table_names (Optional[List[str]]): List of specific table names to retrieve.
+                If None, returns all non-system tables.
+
+        Returns:
+            Response: DataFrame with columns:
+                - TABLE_NAME: Name of the index
+                - TABLE_TYPE: Type of table (always 'BASE TABLE' for Elasticsearch)
+
+        Example:
+            >>> handler.meta_get_tables(['products', 'orders'])
+            >>> handler.meta_get_tables()  # Returns all tables
+        """
+        logger.debug(f"Getting table metadata for: {table_names}")
+
+        # Get all tables using SHOW TABLES
+        query = "SHOW TABLES"
         result = self.native_query(query)
 
+        if result.type != RESPONSE_TYPE.TABLE:
+            return result
+
         df = result.data_frame
-        df = df.drop("mapping", axis=1)
-        result.data_frame = df.rename(columns={"column": "column_name", "type": "data_type"})
 
+        # Filter out system indexes (starting with .)
+        df = df[~df["name"].str.startswith(".")]
+
+        # Filter by requested table names if provided
+        if table_names:
+            df = df[df["name"].isin(table_names)]
+
+        # Drop unnecessary columns and rename to match spec
+        df = df.drop(["catalog", "kind"], axis=1, errors="ignore")
+        df = df.rename(columns={"name": "TABLE_NAME", "type": "TABLE_TYPE"})
+
+        result.data_frame = df
         return result
+
+    def meta_get_columns(self, table_names: Optional[List[str]] = None) -> Response:
+        """
+        Retrieves column metadata for tables (indices) in the Elasticsearch host.
+
+        Args:
+            table_names (Optional[List[str]]): List of specific table names to retrieve columns for.
+                If None, returns columns for all tables.
+
+        Returns:
+            Response: DataFrame with columns:
+                - TABLE_NAME: Name of the index
+                - COLUMN_NAME: Name of the field/column
+                - DATA_TYPE: Elasticsearch data type
+
+        Example:
+            >>> handler.meta_get_columns(['products'])
+            >>> handler.meta_get_columns()  # Returns columns for all tables
+        """
+        logger.debug(f"Getting column metadata for tables: {table_names}")
+
+        # If no table names specified, get all tables first
+        if not table_names:
+            tables_response = self.meta_get_tables()
+            if tables_response.type == RESPONSE_TYPE.ERROR:
+                return tables_response
+            table_names = tables_response.data_frame["TABLE_NAME"].tolist()
+
+        # Collect columns for each table
+        all_columns_data = []
+        for table_name in table_names:
+            try:
+                query = f"DESCRIBE {table_name}"
+                result = self.native_query(query)
+
+                if result.type == RESPONSE_TYPE.TABLE:
+                    df = result.data_frame
+                    df = df.drop("mapping", axis=1, errors="ignore")
+                    df = df.rename(columns={"column": "COLUMN_NAME", "type": "DATA_TYPE"})
+                    # Add TABLE_NAME column
+                    df["TABLE_NAME"] = table_name
+                    all_columns_data.append(df)
+            except Exception as e:
+                logger.warning(f"Failed to get columns for table {table_name}: {e}")
+                continue
+
+        # Combine all results
+        if all_columns_data:
+            combined_df = DataFrame()
+            for df in all_columns_data:
+                combined_df = combined_df._append(df, ignore_index=True) if not combined_df.empty else df
+            # Reorder columns to match spec
+            combined_df = combined_df[["TABLE_NAME", "COLUMN_NAME", "DATA_TYPE"]]
+            return Response(RESPONSE_TYPE.TABLE, data_frame=combined_df)
+        else:
+            return Response(
+                RESPONSE_TYPE.TABLE, data_frame=DataFrame(columns=["TABLE_NAME", "COLUMN_NAME", "DATA_TYPE"])
+            )
diff --git a/mindsdb/integrations/handlers/elasticsearch_handler/requirements.txt b/mindsdb/integrations/handlers/elasticsearch_handler/requirements.txt
index 5b0adfd5730..35b2d6333ae 100644
--- a/mindsdb/integrations/handlers/elasticsearch_handler/requirements.txt
+++ b/mindsdb/integrations/handlers/elasticsearch_handler/requirements.txt
@@ -1,2 +1,2 @@
-elasticsearch>=8.0.0,<9.0.0
-urllib3>=2.6.0 # not directly required, pinned by Snyk to avoid a vulnerability
+elasticsearch>=7.13.4,<9.0.0
+elasticsearch-dbapi>=0.2.9
\ No newline at end of file
diff --git a/mindsdb/integrations/handlers/file_handler/file_handler.py b/mindsdb/integrations/handlers/file_handler/file_handler.py
index c6c66408caa..6a1fc443ee4 100644
--- a/mindsdb/integrations/handlers/file_handler/file_handler.py
+++ b/mindsdb/integrations/handlers/file_handler/file_handler.py
@@ -7,11 +7,15 @@
 from mindsdb_sql_parser.ast import CreateTable, DropTables, Insert, Select, Identifier
 from mindsdb_sql_parser.ast.base import ASTNode
 
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 from mindsdb.api.executor.utilities.sql import query_dfs
 from mindsdb.integrations.libs.base import DatabaseHandler
-from mindsdb.integrations.libs.response import RESPONSE_TYPE
-from mindsdb.integrations.libs.response import HandlerResponse as Response
-from mindsdb.integrations.libs.response import HandlerStatusResponse as StatusResponse
+from mindsdb.integrations.libs.response import (
+    RESPONSE_TYPE,
+    HandlerResponse as Response,
+    HandlerStatusResponse as StatusResponse,
+    INF_SCHEMA_COLUMNS_NAMES_SET,
+)
 from mindsdb.utilities import log
 
 
@@ -211,16 +215,23 @@ def get_tables(self) -> Response:
 
     def get_columns(self, table_name) -> Response:
         file_meta = self.file_controller.get_file_meta(table_name)
+        if file_meta is None:
+            result = Response(
+                RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame([], columns=list(INF_SCHEMA_COLUMNS_NAMES_SET))
+            )
+            result.to_columns_table_response(map_type_fn=lambda _: MYSQL_DATA_TYPE.TEXT)
+            return result
         result = Response(
             RESPONSE_TYPE.TABLE,
             data_frame=pd.DataFrame(
                 [
                     {
-                        "Field": x["name"].strip() if isinstance(x, dict) else x.strip(),
-                        "Type": "str",
+                        "COLUMN_NAME": x["name"].strip() if isinstance(x, dict) else x.strip(),
+                        "DATA_TYPE": "str",
                     }
                     for x in file_meta["columns"]
                 ]
             ),
         )
+        result.to_columns_table_response(map_type_fn=lambda _: MYSQL_DATA_TYPE.TEXT)
         return result
diff --git a/mindsdb/integrations/handlers/freshdesk_handler/README.md b/mindsdb/integrations/handlers/freshdesk_handler/README.md
new file mode 100644
index 00000000000..82190ed9426
--- /dev/null
+++ b/mindsdb/integrations/handlers/freshdesk_handler/README.md
@@ -0,0 +1,65 @@
+# Freshdesk Integration
+
+This documentation describes the integration of MindsDB with [Freshdesk](https://www.Freshdesk.com/), which provides software-as-a-service products related to customer support, sales, and other customer communications.
+
+The integration allows MindsDB to access data from Freshdesk and enhance it with AI capabilities.
+
+## Prerequisites
+
+Before proceeding, ensure the following prerequisites are met:
+
+1. Install MindsDB locally via [Docker](https://docs.mindsdb.com/setup/self-hosted/docker) or [Docker Desktop](https://docs.mindsdb.com/setup/self-hosted/docker-desktop).
+2. To connect Freshdesk to MindsDB, install the required dependencies following [this instruction](https://docs.mindsdb.com/setup/self-hosted/docker#install-dependencies).
+
+## Connection
+
+Establish a connection to Freshdesk from MindsDB by executing the following SQL command and providing its [handler name](https://github.com/mindsdb/mindsdb/tree/main/mindsdb/integrations/handlers/Freshdesk_handler) as an engine.
+
+```sql
+CREATE DATABASE freshdesk_datasource
+WITH
+    ENGINE = 'freshdesk',
+    PARAMETERS = {
+      "api_key":"your_api_key_here",
+      "domain": "yourcompany.freshdesk.com"
+    };
+```
+
+Required connection parameters include the following:
+
+* `api_key`: The API key for the Freshdesk account.
+* `domain`: The Freshdesk domain (e.g., yourcompany.freshdesk.com).
+
+<Tip>
+For enabling, generating and deleting API access, refer [Managing access to the Freshdesk API](https://support.Freshdesk.com/hc/en-us/articles/4408889192858-Managing-access-to-the-Freshdesk-API)
+</Tip>
+
+## Usage
+
+Retrieve data from a specified table by providing the integration and table names:
+
+```sql
+SELECT *
+FROM freshdesk_datasource.table_name
+LIMIT 10;
+```
+
+Retrieve data for a specific ticket by providing the id:
+
+```sql
+SELECT *
+FROM freshdesk_datasource.tickets
+where id="<ticket-id>";
+```
+
+
+<Note>
+The above examples utilize `freshdesk_datasource` as the datasource name, which is defined in the `CREATE DATABASE` command.
+</Note>
+
+## Supported Tables
+
+The Freshdesk integration supports the following tables:
+
+* `agents` : The table lists all the agents.
+* `tickets` : The table lists all the tickets.
\ No newline at end of file
diff --git a/mindsdb/integrations/handlers/freshdesk_handler/__about__.py b/mindsdb/integrations/handlers/freshdesk_handler/__about__.py
new file mode 100644
index 00000000000..da26a08424e
--- /dev/null
+++ b/mindsdb/integrations/handlers/freshdesk_handler/__about__.py
@@ -0,0 +1,9 @@
+__title__ = "MindsDB Freshdesk handler"
+__package_name__ = "mindsdb_freshdesk_handler"
+__version__ = "0.0.1"
+__description__ = "MindsDB handler for Freshdesk"
+__author__ = "Vignesh S M"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2023 - mindsdb"
diff --git a/mindsdb/integrations/handlers/freshdesk_handler/__init__.py b/mindsdb/integrations/handlers/freshdesk_handler/__init__.py
new file mode 100644
index 00000000000..ca82e320104
--- /dev/null
+++ b/mindsdb/integrations/handlers/freshdesk_handler/__init__.py
@@ -0,0 +1,30 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+from .connection_args import connection_args, connection_args_example
+
+try:
+    from .freshdesk_handler import FreshdeskHandler as Handler
+
+    import_error = None  # noqa
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Freshdesk"
+name = "freshdesk"
+type = HANDLER_TYPE.DATA
+icon_path = "icon.svg"
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "import_error",
+    "icon_path",
+    "connection_args_example",
+    "connection_args",
+]
diff --git a/mindsdb/integrations/handlers/freshdesk_handler/connection_args.py b/mindsdb/integrations/handlers/freshdesk_handler/connection_args.py
new file mode 100644
index 00000000000..f279bd7d459
--- /dev/null
+++ b/mindsdb/integrations/handlers/freshdesk_handler/connection_args.py
@@ -0,0 +1,22 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+connection_args = OrderedDict(
+    api_key={
+        "type": ARG_TYPE.STR,
+        "description": "Freshdesk API key",
+        "required": True,
+        "label": "api_key",
+        "secret": True,
+    },
+    domain={
+        "type": ARG_TYPE.STR,
+        "description": "Freshdesk domain (e.g., yourcompany.freshdesk.com)",
+        "required": True,
+        "label": "domain",
+    },
+)
+
+connection_args_example = OrderedDict(api_key="your_api_key_here", domain="yourcompany.freshdesk.com")
diff --git a/mindsdb/integrations/handlers/freshdesk_handler/freshdesk_handler.py b/mindsdb/integrations/handlers/freshdesk_handler/freshdesk_handler.py
new file mode 100644
index 00000000000..cc1dde9e9ac
--- /dev/null
+++ b/mindsdb/integrations/handlers/freshdesk_handler/freshdesk_handler.py
@@ -0,0 +1,97 @@
+from mindsdb_sql_parser import parse_sql
+
+from mindsdb.integrations.handlers.freshdesk_handler.freshdesk_tables import FreshdeskAgentsTable, FreshdeskTicketsTable
+
+from mindsdb.integrations.libs.api_handler import APIHandler
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+)
+from mindsdb.utilities import log
+from freshdesk.v2.api import API
+
+logger = log.getLogger(__name__)
+
+
+class FreshdeskHandler(APIHandler):
+    """The Freshdesk handler implementation"""
+
+    def __init__(self, name: str, **kwargs):
+        """Initialize the freshdesk handler.
+
+        Parameters
+        ----------
+        name : str
+            name of a handler instance
+        """
+        super().__init__(name)
+
+        connection_data = kwargs.get("connection_data", {})
+        self.connection_data = connection_data
+        self.kwargs = kwargs
+        self.freshdesk_client: API = None
+        self.is_connected = False
+
+        self._register_table("agents", FreshdeskAgentsTable(self))
+        self._register_table("tickets", FreshdeskTicketsTable(self))
+
+    def connect(self) -> StatusResponse:
+        """Set up the connection required by the handler.
+
+        Returns
+        -------
+        StatusResponse
+            connection object
+        """
+        resp = StatusResponse(False)
+        try:
+            if not self.connection_data.get("domain"):
+                raise ValueError("Missing required parameter: domain")
+            if not self.connection_data.get("api_key"):
+                raise ValueError("Missing required parameter: api_key")
+
+            self.freshdesk_client = API(domain=self.connection_data["domain"], api_key=self.connection_data["api_key"])
+            # Test the connection by getting new tickets
+            self.freshdesk_client.tickets.list_new_and_my_open_tickets(page=1, per_page=1)
+            self.is_connected = True
+            resp.success = True
+        except KeyError as ex:
+            resp.success = False
+            resp.error_message = f"Missing required connection parameter: {str(ex)}"
+            self.is_connected = False
+        except ValueError as ex:
+            resp.success = False
+            resp.error_message = str(ex)
+            self.is_connected = False
+        except Exception as ex:
+            resp.success = False
+            resp.error_message = f"Failed to connect to Freshdesk: {str(ex)}"
+            self.is_connected = False
+        return resp
+
+    def check_connection(self) -> StatusResponse:
+        """Check connection to the handler.
+
+        Returns
+        -------
+        StatusResponse
+            Status confirmation
+        """
+        response = self.connect()
+        self.is_connected = response.success
+        return response
+
+    def native_query(self, query: str) -> StatusResponse:
+        """Receive and process a raw query.
+
+        Parameters
+        ----------
+        query : str
+            query in a native format
+
+        Returns
+        -------
+        StatusResponse
+            Request status
+        """
+        ast = parse_sql(query)
+        return self.query(ast)
diff --git a/mindsdb/integrations/handlers/freshdesk_handler/freshdesk_tables.py b/mindsdb/integrations/handlers/freshdesk_handler/freshdesk_tables.py
new file mode 100644
index 00000000000..e896a78cb14
--- /dev/null
+++ b/mindsdb/integrations/handlers/freshdesk_handler/freshdesk_tables.py
@@ -0,0 +1,263 @@
+import pandas as pd
+from typing import List, Dict, Tuple
+from mindsdb.integrations.libs.api_handler import APITable
+from mindsdb.integrations.utilities.handlers.query_utilities import (
+    SELECTQueryParser,
+    SELECTQueryExecutor,
+)
+from mindsdb.utilities import log
+from mindsdb_sql_parser import ast
+from urllib.parse import quote
+
+logger = log.getLogger(__name__)
+
+
+class FreshdeskAgentsTable(APITable):
+    """Freshdesk Agents Table implementation"""
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        """Pulls data from the freshdesk list agents API
+
+        Parameters
+        ----------
+        query : ast.Select
+            Given SQL SELECT query
+
+        Returns
+        -------
+        pd.DataFrame
+            Freshdesk agents
+        """
+
+        select_statement_parser = SELECTQueryParser(query, "agents", self.get_columns())
+        selected_columns, where_conditions, order_by_conditions, result_limit = select_statement_parser.parse_query()
+
+        subset_where_conditions, filter_conditions = self.get_conditions(where_conditions)
+
+        df = self.get_freshdesk_agents(filter_conditions)
+
+        select_statement_executor = SELECTQueryExecutor(
+            df, selected_columns, subset_where_conditions, order_by_conditions, result_limit
+        )
+        df = select_statement_executor.execute_query()
+        return df
+
+    def get_conditions(self, where_conditions) -> Tuple:
+        subset_where_conditions = []
+        filter_conditions = {}
+
+        for op, arg1, arg2 in where_conditions:
+            if arg1 in self.get_columns():
+                if arg1 in self.get_api_filter_columns() and op == "=":
+                    filter_conditions[self.get_api_filter_columns()[arg1]] = arg2
+                else:
+                    subset_where_conditions.append([op, arg1, arg2])
+        return subset_where_conditions, filter_conditions
+
+    def get_freshdesk_agents(self, api_filters):
+        agents = self.handler.freshdesk_client.agents.list_agents(**api_filters)
+        response = []
+
+        for agent in agents:
+            response.append(self.agent_to_dict(agent))
+
+        return pd.json_normalize(response, sep="_").reindex(columns=self.get_columns(), fill_value=None)
+
+    def get_columns(self) -> List[str]:
+        """Gets all columns to be returned in pandas DataFrame responses"""
+        return [
+            "available",
+            "occasional",
+            "id",
+            "ticket_scope",
+            "created_at",
+            "updated_at",
+            "last_active_at",
+            "available_since",
+            "type",
+            "deactivated",
+            "signature",
+            "focus_mode",
+            "contact_active",
+            "contact_email",
+            "contact_job_title",
+            "contact_language",
+            "contact_last_login_at",
+            "contact_mobile",
+            "contact_name",
+            "contact_phone",
+            "contact_time_zone",
+            "contact_created_at",
+            "contact_updated_at",
+        ]
+
+    def get_api_filter_columns(self) -> Dict[str, str]:
+        """Gets all columns that can be used to filter through the API directly"""
+        return {
+            "contact_email": "email",
+            "contact_mobile": "mobile",
+            "contact_phone": "phone",
+            "contact_state": "state",
+        }
+
+    def agent_to_dict(self, agent):
+        dict = {col: getattr(agent, col, None) for col in self.get_columns()}
+        dict["contact"] = getattr(agent, "contact", None)
+        return dict
+
+
+class FreshdeskTicketsTable(APITable):
+    """Freshdesk Tickets Table implementation"""
+
+    PRIORITY_MAP = {"low": 1, "medium": 2, "high": 3, "urgent": 4}
+    STATUS_MAP = {"open": 2, "pending": 3, "resolved": 4, "closed": 5}
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        """Pulls data from the freshdesk list tickets API
+
+        Parameters
+        ----------
+        query : ast.Select
+            Given SQL SELECT query
+
+        Returns
+        -------
+        pd.DataFrame
+            Freshdesk tickets
+        """
+
+        select_statement_parser = SELECTQueryParser(query, "tickets", self.get_columns())
+
+        selected_columns, where_conditions, order_by_conditions, result_limit = select_statement_parser.parse_query()
+
+        subset_where_conditions, filter_conditions = self.get_conditions(where_conditions)
+
+        df = self.get_freshdesk_tickets(filter_conditions)
+
+        select_statement_executor = SELECTQueryExecutor(
+            df, selected_columns, subset_where_conditions, order_by_conditions, result_limit
+        )
+
+        df = select_statement_executor.execute_query()
+        return df
+
+    def get_conditions(self, where_conditions) -> Tuple:
+        subset_where_conditions = []
+        search_conditions = []
+
+        for op, arg1, val in where_conditions:
+            if arg1 in self.get_api_filter_columns() and op in self.get_operator_map().keys():
+                if arg1 == "priority" and isinstance(val, str):
+                    val = self.PRIORITY_MAP.get(val.lower(), val)
+                if arg1 == "status" and isinstance(val, str):
+                    val = self.STATUS_MAP.get(val.lower(), val)
+                search_conditions.append((op, arg1, val))
+            else:
+                subset_where_conditions.append([op, arg1, val])
+
+        return subset_where_conditions, search_conditions
+
+    def get_freshdesk_tickets(self, filter_conditions):
+        if len(filter_conditions) > 0:
+            tickets = self.handler.freshdesk_client.tickets.filter_tickets(
+                query=self.build_freshdesk_api_filter_query(filter_conditions)
+            )
+        else:
+            tickets = self.handler.freshdesk_client.tickets.list_tickets(filter_name=None)
+
+        response = []
+
+        for ticket in tickets:
+            response.append(self.ticket_to_dict(ticket))
+
+        return pd.json_normalize(response, sep="_").reindex(columns=self.get_columns(), fill_value=None)
+
+    def build_freshdesk_api_filter_query(self, conditions):
+        """
+        Build Freshdesk API filter query string, quoting strings and mapping enums.
+        """
+
+        op_map = self.get_operator_map()
+        parts = []
+
+        for op, field, value in conditions:
+            freshdesk_operator = op_map.get(op)
+            if freshdesk_operator is None:
+                raise ValueError(f"Unsupported operator: {op}")
+
+            if isinstance(value, str):
+                escaped_value = value.replace("'", "'")
+                value_str = f"'{escaped_value}'"
+            else:
+                value_str = str(value)
+
+            parts.append(f"{field}:{value_str}")
+
+        query_string = " AND ".join(parts)
+        return quote(query_string)
+
+    def get_operator_map(self):
+        """Mapping of sql where operators to freshdesk API query operators"""
+        return {
+            "=": ":",
+            ">": ":>",
+            "<": ":<",
+            ">=": ":>",
+            "<=": ":<",
+        }
+
+    def ticket_to_dict(self, ticket):
+        return {col: getattr(ticket, col, None) for col in self.get_columns()}
+
+    def get_columns(self) -> List[str]:
+        """Gets all columns to be returned in pandas DataFrame responses"""
+        return [
+            "attachments",
+            "cc_emails",
+            "company_id",
+            "custom_fields",
+            "deleted",
+            "description",
+            "description_text",
+            "due_by",
+            "email",
+            "email_config_id",
+            "facebook_id",
+            "fr_due_by",
+            "fr_escalated",
+            "fwd_emails",
+            "group_id",
+            "id",
+            "is_escalated",
+            "name",
+            "phone",
+            "priority",
+            "product_id",
+            "reply_cc_emails",
+            "requester_id",
+            "responder_id",
+            "source",
+            "spam",
+            "status",
+            "subject",
+            "tags",
+            "to_emails",
+            "twitter_id",
+            "type",
+            "created_at",
+            "updated_at",
+        ]
+
+    def get_api_filter_columns(self) -> Dict[str, str]:
+        """Gets all columns that can be used to filter through the API directly"""
+
+        return {
+            "status": "status",
+            "priority": "priority",
+            "type": "type",
+            "group_id": "group_id",
+            "agent_id": "agent_id",
+            "created_at": "created_at",
+            "updated_at": "updated_at",
+            "fr_due_by": "fr_due_by",
+        }
diff --git a/mindsdb/integrations/handlers/freshdesk_handler/icon.svg b/mindsdb/integrations/handlers/freshdesk_handler/icon.svg
new file mode 100644
index 00000000000..ecb5c6e0c6f
--- /dev/null
+++ b/mindsdb/integrations/handlers/freshdesk_handler/icon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64"><path d="M31.9 0h24.036A8 8 0 0 1 64 8.073V32.1C64 49.722 49.722 64 32.1 64h-.182A31.89 31.89 0 0 1 0 32.109C0 14.437 14.254.182 31.9 0z" fill="#25c16f"/><path d="M31.9 14.255c-8.093 0-14.654 6.56-14.654 14.654v9.964c.058 2.667 2.206 4.815 4.873 4.873h4.145V32.3h-5.6v-3.2c.34-6.026 5.327-10.74 11.364-10.74S43.04 23.065 43.38 29.1v3.2H37.7v11.454h3.745v.182c-.04 2.474-2.035 4.47-4.5 4.5h-4.473c-.364 0-.764.182-.764.545a.8.8 0 0 0 .764.764h4.5c3.205-.02 5.798-2.613 5.818-5.818v-.364a4.8 4.8 0 0 0 3.745-4.727V29.1c.182-8.254-6.364-14.836-14.654-14.836z" fill="#fff"/></svg>
\ No newline at end of file
diff --git a/mindsdb/integrations/handlers/freshdesk_handler/requirements.txt b/mindsdb/integrations/handlers/freshdesk_handler/requirements.txt
new file mode 100644
index 00000000000..07a7ac52291
--- /dev/null
+++ b/mindsdb/integrations/handlers/freshdesk_handler/requirements.txt
@@ -0,0 +1 @@
+python-freshdesk
\ No newline at end of file
diff --git a/mindsdb/integrations/handlers/freshdesk_handler/tests/__init__.py b/mindsdb/integrations/handlers/freshdesk_handler/tests/__init__.py
new file mode 100644
index 00000000000..f83bf577364
--- /dev/null
+++ b/mindsdb/integrations/handlers/freshdesk_handler/tests/__init__.py
@@ -0,0 +1 @@
+# Tests for Freshdesk Handler
diff --git a/mindsdb/integrations/handlers/freshdesk_handler/tests/test_freshdesk_handler.py b/mindsdb/integrations/handlers/freshdesk_handler/tests/test_freshdesk_handler.py
new file mode 100644
index 00000000000..3d91c03ed55
--- /dev/null
+++ b/mindsdb/integrations/handlers/freshdesk_handler/tests/test_freshdesk_handler.py
@@ -0,0 +1,207 @@
+import unittest
+from unittest.mock import Mock, patch
+import pandas as pd
+from mindsdb_sql_parser import parse_sql
+
+from mindsdb.integrations.handlers.freshdesk_handler.freshdesk_handler import FreshdeskHandler
+from mindsdb.integrations.handlers.freshdesk_handler.freshdesk_tables import (
+    FreshdeskAgentsTable,
+    FreshdeskTicketsTable,
+)
+
+
+class TestFreshdeskHandler(unittest.TestCase):
+    """Test cases for Freshdesk Handler"""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up test fixtures before running tests."""
+        cls.kwargs = {"connection_data": {"domain": "test.freshdesk.com", "api_key": "test_api_key_123"}}
+        cls.handler = FreshdeskHandler("test_freshdesk_handler", **cls.kwargs)
+        cls.agents_table = FreshdeskAgentsTable(cls.handler)
+        cls.tickets_table = FreshdeskTicketsTable(cls.handler)
+
+    def setUp(self):
+        """Set up test fixtures before each test method."""
+        # Mock the freshdesk client
+        self.mock_client = Mock()
+        self.handler.freshdesk_client = self.mock_client
+        self.handler.is_connected = True
+
+    def _get_agents_mock_data(self, num_records=3):
+        """Helper method to create mock agents data."""
+        return pd.DataFrame(
+            {
+                "id": list(range(1, num_records + 1)),
+                "available": ([True, False, True] * ((num_records // 3) + 1))[:num_records],
+                "contact_email": [f"agent{i}@test.com" for i in range(1, num_records + 1)],
+                "contact_mobile": [f"123456789{i}" for i in range(1, num_records + 1)],
+                "contact_name": [f"Agent {i}" for i in range(1, num_records + 1)],
+            }
+        )
+
+    def _get_tickets_mock_data(self, num_records=3, custom_data=None):
+        """Helper method to create mock tickets data."""
+        base_data = {
+            "id": list(range(1, num_records + 1)),
+            "status": list(range(2, num_records + 2)),
+            "priority": list(range(1, num_records + 1)),
+            "subject": [f"Issue {i}" for i in range(1, num_records + 1)],
+            "group_id": list(range(1, num_records + 1)),
+        }
+
+        # Override with custom data if provided
+        if custom_data:
+            base_data.update(custom_data)
+
+        return pd.DataFrame(base_data)
+
+    def test_agents_table_get_conditions(self):
+        """Test get_conditions method for agents table."""
+        where_conditions = [
+            ["=", "contact_email", "test@example.com"],
+            [">", "id", 100],
+            ["=", "contact_mobile", "+1234567890"],
+        ]
+
+        subset_conditions, filter_conditions = self.agents_table.get_conditions(where_conditions)
+
+        # Check that API filter conditions are properly extracted
+        expected_filter_conditions = {"email": "test@example.com", "mobile": "+1234567890"}
+        self.assertEqual(filter_conditions, expected_filter_conditions)
+
+        # Check that non-API filter conditions are in subset
+        expected_subset = [[">", "id", 100]]
+        self.assertEqual(subset_conditions, expected_subset)
+
+    def test_agents_table_select_basic(self):
+        """Test basic select query for agents table."""
+        mock_df = self._get_agents_mock_data()
+
+        with patch.object(self.agents_table, "get_freshdesk_agents", return_value=mock_df):
+            query = "SELECT id, available FROM agents"
+            ast = parse_sql(query)
+            result = self.agents_table.select(ast)
+
+            self.assertIsInstance(result, pd.DataFrame)
+            self.assertEqual(len(result), 3)
+            self.assertIn("id", result.columns)
+            self.assertIn("available", result.columns)
+
+    def test_agents_table_select_with_where(self):
+        """Test select query with WHERE clause for agents table."""
+        mock_df = self._get_agents_mock_data()
+
+        with patch.object(self.agents_table, "get_freshdesk_agents", return_value=mock_df):
+            query = "SELECT id, available, contact_email FROM agents WHERE contact_email = 'agent1@test.com'"
+            ast = parse_sql(query)
+            result = self.agents_table.select(ast)
+
+            self.assertIsInstance(result, pd.DataFrame)
+
+    def test_tickets_table_get_conditions(self):
+        """Test get_conditions method for tickets table."""
+        where_conditions = [["=", "status", "open"], ["=", "priority", "high"], [">", "id", 100], ["=", "group_id", 5]]
+
+        subset_conditions, search_conditions = self.tickets_table.get_conditions(where_conditions)
+
+        # Check that API filter conditions are properly extracted
+        expected_search_conditions = [("=", "status", 2), ("=", "priority", 3), ("=", "group_id", 5)]
+        self.assertEqual(search_conditions, expected_search_conditions)
+
+        # Check that non-API filter conditions are in subset
+        expected_subset = [[">", "id", 100]]
+        self.assertEqual(subset_conditions, expected_subset)
+
+    def test_tickets_table_priority_status_mapping(self):
+        """Test priority and status mapping in get_conditions."""
+        where_conditions = [["=", "priority", "urgent"], ["=", "status", "closed"]]
+
+        subset_conditions, search_conditions = self.tickets_table.get_conditions(where_conditions)
+
+        # Check that string values are mapped to numbers
+        expected_search_conditions = [("=", "priority", 4), ("=", "status", 5)]
+        self.assertEqual(search_conditions, expected_search_conditions)
+
+    def test_tickets_table_build_freshdesk_api_filter_query(self):
+        """Test build_freshdesk_api_filter_query method."""
+        conditions = [("=", "status", 2), ("=", "priority", 3)]
+
+        result = self.tickets_table.build_freshdesk_api_filter_query(conditions)
+
+        # Should return a URL-encoded query string
+        self.assertIn("status%3A2", result)
+        self.assertIn("priority%3A3", result)
+        self.assertIn("AND", result)
+
+    def test_tickets_table_build_freshdesk_api_filter_query_with_strings(self):
+        """Test build_freshdesk_api_filter_query with string values."""
+        conditions = [("=", "status", "open"), ("=", "priority", "high")]
+
+        result = self.tickets_table.build_freshdesk_api_filter_query(conditions)
+
+        # Should handle string values with quotes
+        self.assertIn("status%3A%27open%27", result)
+        self.assertIn("priority%3A%27high%27", result)
+
+    def test_tickets_table_select_basic(self):
+        """Test basic select query for tickets table."""
+        mock_df = self._get_tickets_mock_data()
+
+        with patch.object(self.tickets_table, "get_freshdesk_tickets", return_value=mock_df):
+            query = "SELECT id, status, subject FROM tickets"
+            ast = parse_sql(query)
+            result = self.tickets_table.select(ast)
+
+            self.assertIsInstance(result, pd.DataFrame)
+            self.assertEqual(len(result), 3)
+            self.assertIn("id", result.columns)
+            self.assertIn("status", result.columns)
+            self.assertIn("subject", result.columns)
+
+    def test_tickets_table_select_with_where(self):
+        """Test select query with WHERE clause for tickets table."""
+        mock_df = self._get_tickets_mock_data()
+
+        with patch.object(self.tickets_table, "get_freshdesk_tickets", return_value=mock_df):
+            query = "SELECT id, status, subject FROM tickets WHERE status = 'open'"
+            ast = parse_sql(query)
+            result = self.tickets_table.select(ast)
+
+            self.assertIsInstance(result, pd.DataFrame)
+
+    def test_tickets_table_select_with_limit(self):
+        """Test select query with LIMIT clause for tickets table."""
+        mock_df = self._get_tickets_mock_data(num_records=5)
+
+        with patch.object(self.tickets_table, "get_freshdesk_tickets", return_value=mock_df):
+            query = "SELECT id, status, subject FROM tickets LIMIT 3"
+            ast = parse_sql(query)
+            result = self.tickets_table.select(ast)
+
+            self.assertIsInstance(result, pd.DataFrame)
+            self.assertLessEqual(len(result), 3)
+
+    def test_tickets_table_select_with_order_by(self):
+        """Test select query with ORDER BY clause for tickets table."""
+        # Create custom data with different order for testing
+        custom_data = {
+            "id": [3, 1, 2],
+            "status": [4, 2, 3],
+            "priority": [3, 1, 2],
+            "subject": ["Issue 3", "Issue 1", "Issue 2"],
+            "group_id": [3, 1, 2],
+        }
+        mock_df = self._get_tickets_mock_data(custom_data=custom_data)
+
+        with patch.object(self.tickets_table, "get_freshdesk_tickets", return_value=mock_df):
+            query = "SELECT id, status, subject FROM tickets ORDER BY id"
+            ast = parse_sql(query)
+            result = self.tickets_table.select(ast)
+
+            self.assertIsInstance(result, pd.DataFrame)
+            self.assertEqual(len(result), 3)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/mindsdb/integrations/handlers/gitlab_handler/README.md b/mindsdb/integrations/handlers/gitlab_handler/README.md
index d8ab4df33d3..4a960ee2cff 100644
--- a/mindsdb/integrations/handlers/gitlab_handler/README.md
+++ b/mindsdb/integrations/handlers/gitlab_handler/README.md
@@ -14,6 +14,8 @@ The GitLab handler is initialized with the following parameters:
 - `repository`: a required name of a GitLab repository to connect to
 - `api_key`: an optional GitLab API key to use for authentication
 - `url`: an optional GitLab server URL (defaults to https://gitlab.com)
+- `http_username`: an optional username for HTTP authentication
+- `http_password`: an optional password for HTTP authentication
 
 ## Implemented Features
 
diff --git a/mindsdb/integrations/handlers/gitlab_handler/gitlab_handler.py b/mindsdb/integrations/handlers/gitlab_handler/gitlab_handler.py
index cae572732d8..1a8bb0b2d6f 100644
--- a/mindsdb/integrations/handlers/gitlab_handler/gitlab_handler.py
+++ b/mindsdb/integrations/handlers/gitlab_handler/gitlab_handler.py
@@ -43,11 +43,14 @@ def connect(self) -> StatusResponse:
 
         connection_kwargs = {}
 
-        if self.connection_data.get("url", None):
-            connection_kwargs["url"] = self.connection_data["url"]
-
-        if self.connection_data.get("api_key", None):
-            connection_kwargs["private_token"] = self.connection_data["api_key"]
+        connection_params = ["url", "api_key", "http_username", "http_password"]
+
+        for connection_param in connection_params:
+            if connection_param in self.connection_data.keys():
+                if connection_param == "api_key":
+                    connection_kwargs["private_token"] = self.connection_data["api_key"]
+                else:
+                    connection_kwargs[connection_param] = self.connection_data.get(connection_param, None)
 
         self.connection = gitlab.Gitlab(**connection_kwargs)
         self.is_connected = True
diff --git a/mindsdb/integrations/handlers/hana_handler/hana_handler.py b/mindsdb/integrations/handlers/hana_handler/hana_handler.py
index eb04fd68338..7899bbd5e33 100644
--- a/mindsdb/integrations/handlers/hana_handler/hana_handler.py
+++ b/mindsdb/integrations/handlers/hana_handler/hana_handler.py
@@ -11,7 +11,7 @@
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
-    RESPONSE_TYPE
+    RESPONSE_TYPE,
 )
 from mindsdb.utilities import log
 
@@ -24,7 +24,7 @@ class HanaHandler(DatabaseHandler):
     This handler handles the connection and execution of SQL statements on SAP HANA.
     """
 
-    name = 'hana'
+    name = "hana"
 
     def __init__(self, name: Text, connection_data: Dict, **kwargs: Any) -> None:
         """
@@ -37,6 +37,7 @@ def __init__(self, name: Text, connection_data: Dict, **kwargs: Any) -> None:
         """
         super().__init__(name)
         self.connection_data = connection_data
+        self.address = self.connection_data.get("address")
         self.kwargs = kwargs
 
         self.connection = None
@@ -64,37 +65,35 @@ def connect(self) -> dbapi.Connection:
             return self.connection
 
         # Mandatory connection parameters.
-        if not all(key in self.connection_data for key in ['address', 'port', 'user', 'password']):
-            raise ValueError('Required parameters (address, port, user, password) must be provided.')
+        if not all(key in self.connection_data for key in ["address", "port", "user", "password"]):
+            raise ValueError("Required parameters (address, port, user, password) must be provided.")
 
         config = {
-            'address': self.connection_data['address'],
-            'port': self.connection_data['port'],
-            'user': self.connection_data['user'],
-            'password': self.connection_data['password'],
+            "address": self.connection_data["address"],
+            "port": self.connection_data["port"],
+            "user": self.connection_data["user"],
+            "password": self.connection_data["password"],
         }
 
         # Optional connection parameters.
-        if 'database' in self.connection_data:
-            config['databaseName'] = self.connection_data['database']
+        if "database" in self.connection_data:
+            config["databaseName"] = self.connection_data["database"]
 
-        if 'schema' in self.connection_data:
-            config['currentSchema'] = self.connection_data['schema']
+        if "schema" in self.connection_data:
+            config["currentSchema"] = self.connection_data["schema"]
 
-        if 'encrypt' in self.connection_data:
-            config['encrypt'] = self.connection_data['encrypt']
+        if "encrypt" in self.connection_data:
+            config["encrypt"] = self.connection_data["encrypt"]
 
         try:
-            self.connection = dbapi.connect(
-                **config
-            )
+            self.connection = dbapi.connect(**config)
             self.is_connected = True
             return self.connection
         except Error as known_error:
-            logger.error(f'Error connecting to SAP HANA, {known_error}!')
+            logger.error(f"Error connecting to SAP HANA, {known_error}!")
             raise
         except Exception as unknown_error:
-            logger.error(f'Unknown error connecting to Teradata, {unknown_error}!')
+            logger.error(f"Unknown error connecting to SAP HANA, {unknown_error}!")
             raise
 
     def disconnect(self) -> None:
@@ -118,13 +117,13 @@ def check_connection(self) -> StatusResponse:
         try:
             connection = self.connect()
             with connection.cursor() as cur:
-                cur.execute('SELECT 1 FROM SYS.DUMMY')
+                cur.execute("SELECT 1 FROM SYS.DUMMY")
             response.success = True
         except (Error, ProgrammingError, ValueError) as known_error:
-            logger.error(f'Connection check to SAP HANA failed, {known_error}!')
+            logger.error(f"Connection check to SAP HANA failed, {known_error}!")
             response.error_message = str(known_error)
         except Exception as unknown_error:
-            logger.error(f'Connection check to SAP HANA failed due to an unknown error, {unknown_error}!')
+            logger.error(f"Connection check to SAP HANA failed due to an unknown error, {unknown_error}!")
             response.error_message = str(unknown_error)
 
         if response.success is True and need_to_close:
@@ -154,29 +153,15 @@ def native_query(self, query: Text) -> Response:
                     response = Response(RESPONSE_TYPE.OK)
                 else:
                     result = cur.fetchall()
-                    response = Response(
-                        RESPONSE_TYPE.TABLE,
-                        DataFrame(
-                            result,
-                            columns=[x[0] for x in cur.description]
-                        )
-                    )
+                    response = Response(RESPONSE_TYPE.TABLE, DataFrame(result, columns=[x[0] for x in cur.description]))
                 connection.commit()
             except ProgrammingError as programming_error:
-                logger.error(f'Error running query: {query} on {self.address}!')
-                response = Response(
-                    RESPONSE_TYPE.ERROR,
-                    error_code=0,
-                    error_message=str(programming_error)
-                )
+                logger.error(f"Error running query: {query} on {self.address}!")
+                response = Response(RESPONSE_TYPE.ERROR, error_code=0, error_message=str(programming_error))
                 connection.rollback()
             except Exception as unknown_error:
-                logger.error(f'Unknown error running query: {query} on {self.address}!')
-                response = Response(
-                    RESPONSE_TYPE.ERROR,
-                    error_code=0,
-                    error_message=str(unknown_error)
-                )
+                logger.error(f"Unknown error running query: {query} on {self.address}!")
+                response = Response(RESPONSE_TYPE.ERROR, error_code=0, error_message=str(unknown_error))
                 connection.rollback()
 
         if need_to_close is True:
diff --git a/mindsdb/integrations/handlers/hubspot_handler/README.md b/mindsdb/integrations/handlers/hubspot_handler/README.md
index 67bc8be809c..032024df64e 100644
--- a/mindsdb/integrations/handlers/hubspot_handler/README.md
+++ b/mindsdb/integrations/handlers/hubspot_handler/README.md
@@ -12,7 +12,6 @@ HubSpot handler for MindsDB provides interfaces to connect to HubSpot via APIs a
   - [Installation](#installation)
   - [Authentication](#authentication)
     - [Personal Access Token Authentication](#personal-access-token-authentication)
-    - [OAuth Authentication](#oauth-authentication)
   - [Supported Tables](#supported-tables)
     - [Core CRM and Engagement Tables](#core-crm-and-engagement-tables)
     - [Metadata Tables](#metadata-tables)
@@ -59,15 +58,6 @@ Recommended for server-to-server integrations and production environments.
 4. Configure required scopes for the tables you plan to access
 5. Copy the generated access token
 
-### OAuth Authentication
-
-Recommended for applications requiring user consent and dynamic scope management.
-
-**Required OAuth Parameters:**
-- `client_id`: Your app's client identifier
-- `client_secret`: Your app's client secret (store securely)
-
-OAuth token exchange and refresh are handled externally.
 
 ## Supported Tables
 
@@ -86,6 +76,7 @@ These tables support `SELECT`, `INSERT`, `UPDATE`, and `DELETE` operations.
 | `emails` | Email log records | https://developers.hubspot.com/docs/api-reference/crm-emails-v3/guide |
 | `meetings` | Meeting records | https://developers.hubspot.com/docs/api-reference/crm-meetings-v3/guide |
 | `notes` | Timeline notes | https://developers.hubspot.com/docs/api-reference/crm-notes-v3/guide |
+| `leads` | Lead records including lead status and source | https://developers.hubspot.com/docs/api-reference/crm-leads-v3/guide |
 
 ### Metadata Tables
 
diff --git a/mindsdb/integrations/handlers/hubspot_handler/connection_args.py b/mindsdb/integrations/handlers/hubspot_handler/connection_args.py
index 795f84e8863..9154946b884 100644
--- a/mindsdb/integrations/handlers/hubspot_handler/connection_args.py
+++ b/mindsdb/integrations/handlers/hubspot_handler/connection_args.py
@@ -1,29 +1,59 @@
 from collections import OrderedDict
 
-from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+from mindsdb.integrations.libs.const import (
+    HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE,
+)
 
 connection_args = OrderedDict(
     access_token={
         "type": ARG_TYPE.STR,
-        "description": "The access token for the HubSpot API. Required for direct access token authentication.",
+        "description": ("The access token for the HubSpot API. Required for direct access token authentication."),
         "required": False,
         "label": "Access Token",
     },
     client_id={
         "type": ARG_TYPE.STR,
-        "description": "The client ID (consumer key) from your HubSpot app for OAuth authentication.",
+        "description": ("The client ID (consumer key) from your HubSpot app for OAuth authentication."),
         "required": False,
         "label": "Client ID",
     },
     client_secret={
         "type": ARG_TYPE.PWD,
-        "description": "The client secret (consumer secret) from your HubSpot app for OAuth authentication.",
+        "description": ("The client secret (consumer secret) from your HubSpot app for OAuth authentication."),
         "secret": True,
         "required": False,
         "label": "Client Secret",
     },
+    scope={
+        "type": ARG_TYPE.STR,
+        "description": "Space-separated required OAuth scopes (scope URL param). Defaults to 'oauth'.",
+        "required": False,
+        "label": "Required Scopes",
+    },
+    optional_scope={
+        "type": ARG_TYPE.STR,
+        "description": "Space-separated optional OAuth scopes.",
+        "required": False,
+        "label": "Optional Scopes",
+    },
+    redirect_uri={
+        "type": ARG_TYPE.STR,
+        "description": ("Optional OAuth callback URI. Defaults to http://localhost:47334/verify-auth."),
+        "required": False,
+        "label": "Redirect URI",
+    },
+    code={
+        "type": ARG_TYPE.STR,
+        "description": "OAuth authorization code returned by HubSpot after user consent. Only used within UI flow.",
+        "required": False,
+        "label": "Authorization Code",
+    },
 )
 
 connection_args_example = OrderedDict(
-    access_token="your_access_token", client_id="your_client_id", client_secret="your_client_secret"
+    access_token="your_access_token",
+    client_id="your_client_id",
+    client_secret="your_client_secret",
+    scopes="crm.objects.contacts.read crm.objects.companies.read",
+    redirect_uri="http://localhost:47334/verify-auth",
 )
diff --git a/mindsdb/integrations/handlers/hubspot_handler/hubspot_association_utils.py b/mindsdb/integrations/handlers/hubspot_handler/hubspot_association_utils.py
index d8b7de1de24..beb9369c515 100644
--- a/mindsdb/integrations/handlers/hubspot_handler/hubspot_association_utils.py
+++ b/mindsdb/integrations/handlers/hubspot_handler/hubspot_association_utils.py
@@ -42,6 +42,10 @@
         ("companies", "primary_company_id"),
         ("deals", "primary_deal_id"),
     ],
+    "leads": [
+        ("contacts", "primary_contact_id"),
+        ("companies", "primary_company_id"),
+    ],
 }
 
 
diff --git a/mindsdb/integrations/handlers/hubspot_handler/hubspot_handler.py b/mindsdb/integrations/handlers/hubspot_handler/hubspot_handler.py
index e70c4dd0139..b979a57c797 100644
--- a/mindsdb/integrations/handlers/hubspot_handler/hubspot_handler.py
+++ b/mindsdb/integrations/handlers/hubspot_handler/hubspot_handler.py
@@ -13,6 +13,7 @@
     EmailsTable,
     MeetingsTable,
     NotesTable,
+    LeadsTable,
     OwnersTable,
     DealStagesTable,
     to_hubspot_property,
@@ -33,6 +34,9 @@
 from mindsdb.utilities import log
 from mindsdb_sql_parser import parse_sql
 
+from mindsdb.integrations.handlers.hubspot_handler.hubspot_oauth import HubSpotOAuth2Manager
+from mindsdb.integrations.utilities.handlers.auth_utilities.exceptions import AuthException
+
 logger = log.getLogger(__name__)
 
 
@@ -117,6 +121,7 @@ def __init__(self, name: str, **kwargs: Any) -> None:
         connection_data = kwargs.get("connection_data", {})
         self.connection_data = connection_data
         self.kwargs = kwargs
+        self.handler_storage = kwargs.get("handler_storage")
 
         self.connection: Optional[HubSpot] = None
         self.is_connected: bool = False
@@ -135,6 +140,7 @@ def __init__(self, name: str, **kwargs: Any) -> None:
         self._register_table("emails", EmailsTable(self))
         self._register_table("meetings", MeetingsTable(self))
         self._register_table("notes", NotesTable(self))
+        self._register_table("leads", LeadsTable(self))
         self._register_table("owners", OwnersTable(self))
         self._register_table("deal_stages", DealStagesTable(self))
 
@@ -147,39 +153,53 @@ def connect(self) -> HubSpot:
             return self.connection
 
         try:
-            if "access_token" in self.connection_data:
-                access_token = self.connection_data["access_token"]
-                if not access_token or not isinstance(access_token, str):
+            access_token = self.connection_data.get("access_token")
+            client_id = self.connection_data.get("client_id")
+            client_secret = self.connection_data.get("client_secret")
+
+            if access_token:
+                if not isinstance(access_token, str) or not access_token.strip():
                     raise ValueError("Invalid access_token provided")
 
                 logger.info("Connecting to HubSpot using access token")
                 self.connection = HubSpot(access_token=access_token)
 
-            elif "client_id" in self.connection_data and "client_secret" in self.connection_data:
-                client_id = self.connection_data["client_id"]
-                client_secret = self.connection_data["client_secret"]
-
-                if not client_id or not client_secret:
-                    raise ValueError("Invalid OAuth credentials provided")
-
+            elif client_id and client_secret:
                 logger.info("Connecting to HubSpot using OAuth credentials")
-                self.connection = HubSpot(client_id=client_id, client_secret=client_secret)
+                oauth_manager = HubSpotOAuth2Manager(
+                    handler_storage=self.handler_storage,
+                    client_id=client_id,
+                    client_secret=client_secret,
+                    scopes=self.connection_data.get("scope"),
+                    optional_scopes=self.connection_data.get("optional_scope"),
+                    redirect_uri=self.connection_data.get("redirect_uri"),
+                    code=self.connection_data.get("code"),
+                    datasource_name=self.name,
+                )
+                logger.info("Attempting to obtain access token via OAuth flow")
+                logger.debug(oauth_manager)
+                self.connection = HubSpot(access_token=oauth_manager.get_access_token())
+
             else:
                 raise ValueError(
                     "Authentication credentials missing. Provide either 'access_token' "
-                    "or both 'client_id' and 'client_secret' for OAuth authentication."
+                    "or OAuth credentials: 'client_id' and 'client_secret'."
                 )
 
             self.is_connected = True
             logger.info("Successfully connected to HubSpot API")
             return self.connection
 
-        except ValueError:
-            logger.error("Failed to connect to HubSpot API")
+        except AuthException:
+            self.connection = None
+            self.is_connected = False
+            logger.info("HubSpot OAuth authorization required")
             raise
         except Exception as e:
-            logger.error("Failed to connect to HubSpot API")
-            raise ValueError(f"Connection to HubSpot failed: {str(e)}")
+            self.connection = None
+            self.is_connected = False
+            logger.error("Failed to connect to HubSpot API: %s", e)
+            raise ValueError(f"Connection to HubSpot failed: {e}") from e
 
     def disconnect(self) -> None:
         """Close connection and cleanup resources."""
@@ -191,6 +211,19 @@ def check_connection(self) -> StatusResponse:
         """Checks whether the API client is connected to Hubspot."""
         response = StatusResponse(False)
 
+        # Defer OAuth code-for-token exchange: CREATE DATABASE runs check_connection
+        # with ephemeral handler_storage, so tokens written here would be discarded;
+        # later requests then fail with BAD_AUTH_CODE. Exchange only when a request
+        if self.connection_data.get("code") and not self.is_connected:
+            from mindsdb.integrations.handlers.hubspot_handler.hubspot_oauth import _STORAGE_KEY
+
+            if not self.handler_storage.encrypted_json_get(_STORAGE_KEY):
+                logger.info(
+                    "Deferring HubSpot check_connection because OAuth code exchange must happen in a persistent context."
+                )
+                response.success = True
+                return response
+
         try:
             self.connect()
 
@@ -213,6 +246,10 @@ def check_connection(self) -> StatusResponse:
                         response.error_message = error_msg
                         response.success = False
 
+        except AuthException as error:
+            response.error_message = str(error)
+            response.redirect_url = error.auth_url
+            return response
         except Exception as e:
             error_msg = _extract_hubspot_error_message(e)
             logger.error(f"HubSpot connection check failed: {error_msg}")
@@ -601,13 +638,14 @@ def _get_table_description(self, table_name: str) -> str:
             "ticket_deals": "HubSpot ticket to deal associations",
             "owners": "HubSpot owners with names and emails",
             "deal_stages": "HubSpot deal pipeline stages with labels",
+            "leads": "HubSpot leads data including lead status, source and other lead properties",
         }
         return descriptions.get(table_name, f"HubSpot {table_name} data")
 
     def _estimate_table_rows(self, table_name: str) -> Optional[int]:
         """Get actual count of rows in a table using HubSpot Search API."""
         try:
-            if table_name in ["companies", "contacts", "deals", "tickets"]:
+            if table_name in ["companies", "contacts", "deals", "tickets", "leads"]:
                 result = getattr(self.connection.crm, table_name).search_api.do_search(
                     public_object_search_request={"limit": 1}
                 )
diff --git a/mindsdb/integrations/handlers/hubspot_handler/hubspot_oauth.py b/mindsdb/integrations/handlers/hubspot_handler/hubspot_oauth.py
new file mode 100644
index 00000000000..9608055edad
--- /dev/null
+++ b/mindsdb/integrations/handlers/hubspot_handler/hubspot_oauth.py
@@ -0,0 +1,151 @@
+import time
+import urllib.parse
+from typing import Optional
+
+from flask import request
+from hubspot import HubSpot
+from hubspot.utils.oauth import get_auth_url
+
+from mindsdb.utilities import log
+from mindsdb.integrations.utilities.handlers.auth_utilities.exceptions import AuthException
+
+logger = log.getLogger(__name__)
+
+_STORAGE_KEY = "hubspot_oauth_tokens"
+_DEFAULT_REDIRECT_PATH = "/verify-auth"
+_TOKEN_EXPIRY_BUFFER = 0.95
+
+
+class HubSpotOAuth2Manager:
+    """
+    Manages HubSpot OAuth2 authorization_code flow for MindsDB.
+    """
+
+    def __init__(
+        self,
+        handler_storage,
+        client_id: str,
+        client_secret: str,
+        scopes: Optional[str] = None,
+        optional_scopes: Optional[str] = None,
+        redirect_uri: Optional[str] = None,
+        code: Optional[str] = None,
+        datasource_name: Optional[str] = None,
+    ) -> None:
+        self.handler_storage = handler_storage
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.scopes = tuple(scopes.split()) if scopes else ("oauth",)
+        self.optional_scopes = tuple(optional_scopes.split()) if optional_scopes else None
+        self.redirect_uri = redirect_uri
+        self.code = code
+        self.datasource_name = datasource_name
+
+    def get_access_token(self) -> str:
+        """
+        Return a valid HubSpot access token.
+        Raises:
+            AuthException: User authorization required; auth_url is attached.
+        """
+        stored = self.handler_storage.encrypted_json_get(_STORAGE_KEY)
+        logger.debug(f"Retrieved stored token data: {stored}")
+        if stored:
+            if time.time() < stored.get("expires_at", 0):
+                return stored["access_token"]
+
+            if stored.get("refresh_token"):
+                try:
+                    return self._refresh_token(stored["refresh_token"])
+                except Exception as e:
+                    logger.warning("HubSpot token refresh failed, reauthorization required: %s", e)
+
+        runtime_code = self._get_runtime_code()
+        if runtime_code:
+            try:
+                return self._exchange_code(runtime_code)
+            except Exception as e:
+                # OAuth codes are single-use and expire quickly.
+                # If the exchange fails (BAD_AUTH_CODE), don't retry — prompt re-authorization.
+                logger.warning("HubSpot code exchange failed (code may be expired/used): %s", e)
+
+        redirect_uri = self._get_redirect_uri()
+        auth_url = get_auth_url(
+            scope=self.scopes,
+            optional_scope=self.optional_scopes,
+            client_id=self.client_id,
+            redirect_uri=redirect_uri,
+        )
+        # Fix for HubSpot's strict URL parsing. Python's URL encode translates spaces to `+`, but
+        # HubSpot's optional_scopes requires `%20` or `,`.
+        auth_url = auth_url.replace("+", "%20")
+
+        # Append state with datasource info so the frontend can complete the connection
+        # even when localStorage context is missing (e.g. script-initiated flows).
+        if self.datasource_name:
+            state_data = urllib.parse.urlencode(
+                {
+                    "datasource_name": self.datasource_name,
+                    "integrations_name": "hubspot",
+                    "client_id": self.client_id,
+                    "client_secret": self.client_secret,
+                    "redirect_uri": redirect_uri,
+                    "scope": " ".join(self.scopes) if self.scopes else "oauth",
+                    "optional_scope": " ".join(self.optional_scopes) if self.optional_scopes else "",
+                }
+            )
+            auth_url += f"&state={urllib.parse.quote(state_data)}"
+
+        raise AuthException(
+            f"HubSpot authorization required. Please visit: {auth_url}",
+            auth_url=auth_url,
+        )
+
+    def _get_runtime_code(self) -> Optional[str]:
+        """Return the OAuth authorization code from explicit value or active request context."""
+        if self.code:
+            return self.code
+        try:
+            return request.args.get("code")
+        except RuntimeError:
+            return None
+
+    def _exchange_code(self, code: str) -> str:
+        """Exchange an authorization code for access and refresh tokens."""
+        response = HubSpot().oauth.tokens_api.create(
+            grant_type="authorization_code",
+            code=code,
+            redirect_uri=self._get_redirect_uri(),
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+        )
+        return self._persist_tokens(response)
+
+    def _refresh_token(self, refresh_token: str) -> str:
+        """Obtain a new access token using the stored refresh token."""
+        response = HubSpot().oauth.tokens_api.create(
+            grant_type="refresh_token",
+            refresh_token=refresh_token,
+            redirect_uri=self._get_redirect_uri(),
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+        )
+        return self._persist_tokens(response)
+
+    def _persist_tokens(self, token_response) -> str:
+        """Save token data to encrypted handler storage and return the access token."""
+        tokens = {
+            "access_token": token_response.access_token,
+            "refresh_token": token_response.refresh_token,
+            "expires_at": time.time() + token_response.expires_in * _TOKEN_EXPIRY_BUFFER,
+        }
+        self.handler_storage.encrypted_json_set(_STORAGE_KEY, tokens)
+        return tokens["access_token"]
+
+    def _get_redirect_uri(self) -> str:
+        if self.redirect_uri:
+            return self.redirect_uri
+        try:
+            origin = request.headers.get("ORIGIN", "http://localhost:47334")
+        except RuntimeError:
+            origin = "http://localhost:47334"
+        return origin + _DEFAULT_REDIRECT_PATH
diff --git a/mindsdb/integrations/handlers/hubspot_handler/hubspot_tables.py b/mindsdb/integrations/handlers/hubspot_handler/hubspot_tables.py
index ad381432023..f2224b42ac7 100644
--- a/mindsdb/integrations/handlers/hubspot_handler/hubspot_tables.py
+++ b/mindsdb/integrations/handlers/hubspot_handler/hubspot_tables.py
@@ -1,4 +1,4 @@
-from typing import List, Dict, Text, Any, Optional, Tuple, Set, Iterable
+from typing import List, Dict, Any, Optional, Tuple, Set, Iterable
 import calendar
 import inspect
 import re
@@ -601,6 +601,17 @@ def _extract(node: ASTNode, **kwargs):
         ("stage_probability", "DECIMAL", "Stage probability"),
         ("stage_archived", "BOOLEAN", "Stage archived"),
     ],
+    "leads": [
+        ("hs_lead_name", "VARCHAR", "Lead name"),
+        ("hs_lead_type", "VARCHAR", "Lead type"),
+        ("hs_lead_label", "VARCHAR", "Lead label/status"),
+        ("hubspot_owner_id", "VARCHAR", "Owner ID"),
+        ("hs_timestamp", "TIMESTAMP", "Lead timestamp"),
+        ("primary_contact_id", "VARCHAR", "Primary associated contact ID"),
+        ("primary_company_id", "VARCHAR", "Primary associated company ID"),
+        ("createdate", "TIMESTAMP", "Creation date"),
+        ("lastmodifieddate", "TIMESTAMP", "Last modification date"),
+    ],
 }
 
 
@@ -1327,7 +1338,7 @@ def modify(self, conditions: List[FilterCondition], values: Dict) -> None:
     def remove(self, conditions: List[FilterCondition]) -> None:
         raise NotImplementedError("Deleting owners via DELETE is not supported.")
 
-    def get_columns(self) -> List[Text]:
+    def get_columns(self) -> List[str]:
         return self._get_default_owner_columns()
 
     @staticmethod
@@ -1393,7 +1404,7 @@ def modify(self, conditions: List[FilterCondition], values: Dict) -> None:
     def remove(self, conditions: List[FilterCondition]) -> None:
         raise NotImplementedError("Deleting deal stages via DELETE is not supported.")
 
-    def get_columns(self) -> List[Text]:
+    def get_columns(self) -> List[str]:
         return self._get_default_deal_stage_columns()
 
     @staticmethod
@@ -1532,7 +1543,7 @@ def remove(self, conditions: List[FilterCondition]) -> None:
         logger.info(f"Deleting {len(company_ids)} compan(ies) matching WHERE conditions")
         self.delete_companies(company_ids)
 
-    def get_columns(self) -> List[Text]:
+    def get_columns(self) -> List[str]:
         return self._get_default_company_columns()
 
     @staticmethod
@@ -1641,7 +1652,7 @@ def _company_to_dict(self, company: Any, columns: Optional[List[str]] = None) ->
         columns = columns or self._get_default_company_columns()
         return self._object_to_dict(company, columns)
 
-    def create_companies(self, companies_data: List[Dict[Text, Any]]) -> None:
+    def create_companies(self, companies_data: List[Dict[str, Any]]) -> None:
         if not companies_data:
             raise ValueError("No company data provided for creation")
 
@@ -1662,7 +1673,7 @@ def create_companies(self, companies_data: List[Dict[Text, Any]]) -> None:
             logger.error(f"Companies creation failed: {str(e)}")
             raise Exception(f"Companies creation failed {e}")
 
-    def update_companies(self, company_ids: List[Text], values_to_update: Dict[Text, Any]) -> None:
+    def update_companies(self, company_ids: List[str], values_to_update: Dict[str, Any]) -> None:
         hubspot = self.handler.connect()
         companies_to_update = [HubSpotObjectBatchInput(id=cid, properties=values_to_update) for cid in company_ids]
         batch_input = BatchInputSimplePublicObjectBatchInput(inputs=companies_to_update)
@@ -1672,7 +1683,7 @@ def update_companies(self, company_ids: List[Text], values_to_update: Dict[Text,
         except Exception as e:
             raise Exception(f"Companies update failed {e}")
 
-    def delete_companies(self, company_ids: List[Text]) -> None:
+    def delete_companies(self, company_ids: List[str]) -> None:
         hubspot = self.handler.connect()
         companies_to_delete = [HubSpotObjectId(id=cid) for cid in company_ids]
         batch_input = BatchInputSimplePublicObjectId(inputs=companies_to_delete)
@@ -1800,7 +1811,7 @@ def remove(self, conditions: List[FilterCondition]) -> None:
         logger.info(f"Deleting {len(contact_ids)} contact(s) matching WHERE conditions")
         self.delete_contacts(contact_ids)
 
-    def get_columns(self) -> List[Text]:
+    def get_columns(self) -> List[str]:
         return self._get_default_contact_columns()
 
     @staticmethod
@@ -1937,7 +1948,7 @@ def _contact_to_dict(
                 **{col: None for col in assoc_columns},
             }
 
-    def create_contacts(self, contacts_data: List[Dict[Text, Any]]) -> None:
+    def create_contacts(self, contacts_data: List[Dict[str, Any]]) -> None:
         if not contacts_data:
             raise ValueError("No contact data provided for creation")
 
@@ -1958,7 +1969,7 @@ def create_contacts(self, contacts_data: List[Dict[Text, Any]]) -> None:
             logger.error(f"Contacts creation failed: {str(e)}")
             raise Exception(f"Contacts creation failed {e}")
 
-    def update_contacts(self, contact_ids: List[Text], values_to_update: Dict[Text, Any]) -> None:
+    def update_contacts(self, contact_ids: List[str], values_to_update: Dict[str, Any]) -> None:
         hubspot = self.handler.connect()
         contacts_to_update = [HubSpotObjectBatchInput(id=cid, properties=values_to_update) for cid in contact_ids]
         batch_input = BatchInputSimplePublicObjectBatchInput(inputs=contacts_to_update)
@@ -1968,7 +1979,7 @@ def update_contacts(self, contact_ids: List[Text], values_to_update: Dict[Text,
         except Exception as e:
             raise Exception(f"Contacts update failed {e}")
 
-    def delete_contacts(self, contact_ids: List[Text]) -> None:
+    def delete_contacts(self, contact_ids: List[str]) -> None:
         hubspot = self.handler.connect()
         contacts_to_delete = [HubSpotObjectId(id=cid) for cid in contact_ids]
         batch_input = BatchInputSimplePublicObjectId(inputs=contacts_to_delete)
@@ -2091,7 +2102,7 @@ def remove(self, conditions: List[FilterCondition]) -> None:
         logger.info(f"Deleting {len(deal_ids)} deal(s) matching WHERE conditions")
         self.delete_deals(deal_ids)
 
-    def get_columns(self) -> List[Text]:
+    def get_columns(self) -> List[str]:
         return self._get_default_deal_columns()
 
     @staticmethod
@@ -2323,7 +2334,7 @@ def _deal_to_dict(
             row = enrich_object_with_associations(deal, "deals", row)
         return row
 
-    def create_deals(self, deals_data: List[Dict[Text, Any]]) -> None:
+    def create_deals(self, deals_data: List[Dict[str, Any]]) -> None:
         if not deals_data:
             raise ValueError("No deal data provided for creation")
 
@@ -2344,7 +2355,7 @@ def create_deals(self, deals_data: List[Dict[Text, Any]]) -> None:
             logger.error(f"Deals creation failed: {str(e)}")
             raise Exception(f"Deals creation failed {e}")
 
-    def update_deals(self, deal_ids: List[Text], values_to_update: Dict[Text, Any]) -> None:
+    def update_deals(self, deal_ids: List[str], values_to_update: Dict[str, Any]) -> None:
         hubspot = self.handler.connect()
         deals_to_update = [HubSpotObjectBatchInput(id=did, properties=values_to_update) for did in deal_ids]
         batch_input = BatchInputSimplePublicObjectBatchInput(inputs=deals_to_update)
@@ -2354,7 +2365,7 @@ def update_deals(self, deal_ids: List[Text], values_to_update: Dict[Text, Any])
         except Exception as e:
             raise Exception(f"Deals update failed {e}")
 
-    def delete_deals(self, deal_ids: List[Text]) -> None:
+    def delete_deals(self, deal_ids: List[str]) -> None:
         hubspot = self.handler.connect()
         deals_to_delete = [HubSpotObjectId(id=did) for did in deal_ids]
         batch_input = BatchInputSimplePublicObjectId(inputs=deals_to_delete)
@@ -2452,7 +2463,7 @@ def remove(self, conditions: List[FilterCondition]) -> None:
         logger.info(f"Deleting {len(ticket_ids)} ticket(s) matching WHERE conditions")
         self.delete_tickets(ticket_ids)
 
-    def get_columns(self) -> List[Text]:
+    def get_columns(self) -> List[str]:
         return self._get_default_ticket_columns()
 
     @staticmethod
@@ -2563,7 +2574,7 @@ def _ticket_to_dict(
             row = enrich_object_with_associations(ticket, "tickets", row)
         return row
 
-    def create_tickets(self, tickets_data: List[Dict[Text, Any]]) -> None:
+    def create_tickets(self, tickets_data: List[Dict[str, Any]]) -> None:
         if not tickets_data:
             raise ValueError("No ticket data provided for creation")
 
@@ -2584,7 +2595,7 @@ def create_tickets(self, tickets_data: List[Dict[Text, Any]]) -> None:
             logger.error(f"Tickets creation failed: {str(e)}")
             raise Exception(f"Tickets creation failed {e}")
 
-    def update_tickets(self, ticket_ids: List[Text], values_to_update: Dict[Text, Any]) -> None:
+    def update_tickets(self, ticket_ids: List[str], values_to_update: Dict[str, Any]) -> None:
         hubspot = self.handler.connect()
         tickets_to_update = [HubSpotObjectBatchInput(id=tid, properties=values_to_update) for tid in ticket_ids]
         batch_input = BatchInputSimplePublicObjectBatchInput(inputs=tickets_to_update)
@@ -2594,7 +2605,7 @@ def update_tickets(self, ticket_ids: List[Text], values_to_update: Dict[Text, An
         except Exception as e:
             raise Exception(f"Tickets update failed {e}")
 
-    def delete_tickets(self, ticket_ids: List[Text]) -> None:
+    def delete_tickets(self, ticket_ids: List[str]) -> None:
         hubspot = self.handler.connect()
         tickets_to_delete = [HubSpotObjectId(id=tid) for tid in ticket_ids]
         batch_input = BatchInputSimplePublicObjectId(inputs=tickets_to_delete)
@@ -2692,7 +2703,7 @@ def remove(self, conditions: List[FilterCondition]) -> None:
         logger.info(f"Deleting {len(task_ids)} task(s) matching WHERE conditions")
         self.delete_tasks(task_ids)
 
-    def get_columns(self) -> List[Text]:
+    def get_columns(self) -> List[str]:
         return self._get_default_task_columns()
 
     @staticmethod
@@ -2805,7 +2816,7 @@ def _task_to_dict(
             row = enrich_object_with_associations(task, "tasks", row)
         return row
 
-    def create_tasks(self, tasks_data: List[Dict[Text, Any]]) -> None:
+    def create_tasks(self, tasks_data: List[Dict[str, Any]]) -> None:
         if not tasks_data:
             raise ValueError("No task data provided for creation")
 
@@ -2826,7 +2837,7 @@ def create_tasks(self, tasks_data: List[Dict[Text, Any]]) -> None:
             logger.error(f"Tasks creation failed: {str(e)}")
             raise Exception(f"Tasks creation failed {e}")
 
-    def update_tasks(self, task_ids: List[Text], values_to_update: Dict[Text, Any]) -> None:
+    def update_tasks(self, task_ids: List[str], values_to_update: Dict[str, Any]) -> None:
         hubspot = self.handler.connect()
         tasks_to_update = [HubSpotObjectBatchInput(id=tid, properties=values_to_update) for tid in task_ids]
         batch_input = BatchInputSimplePublicObjectBatchInput(inputs=tasks_to_update)
@@ -2838,7 +2849,7 @@ def update_tasks(self, task_ids: List[Text], values_to_update: Dict[Text, Any])
         except Exception as e:
             raise Exception(f"Tasks update failed {e}")
 
-    def delete_tasks(self, task_ids: List[Text]) -> None:
+    def delete_tasks(self, task_ids: List[str]) -> None:
         hubspot = self.handler.connect()
         tasks_to_delete = [HubSpotObjectId(id=tid) for tid in task_ids]
         batch_input = BatchInputSimplePublicObjectId(inputs=tasks_to_delete)
@@ -2936,7 +2947,7 @@ def remove(self, conditions: List[FilterCondition]) -> None:
         logger.info(f"Deleting {len(call_ids)} call(s) matching WHERE conditions")
         self.delete_calls(call_ids)
 
-    def get_columns(self) -> List[Text]:
+    def get_columns(self) -> List[str]:
         return self._get_default_call_columns()
 
     @staticmethod
@@ -3049,7 +3060,7 @@ def _call_to_dict(
             row = enrich_object_with_associations(call, "calls", row)
         return row
 
-    def create_calls(self, calls_data: List[Dict[Text, Any]]) -> None:
+    def create_calls(self, calls_data: List[Dict[str, Any]]) -> None:
         if not calls_data:
             raise ValueError("No call data provided for creation")
 
@@ -3070,7 +3081,7 @@ def create_calls(self, calls_data: List[Dict[Text, Any]]) -> None:
             logger.error(f"Calls creation failed: {str(e)}")
             raise Exception(f"Calls creation failed {e}")
 
-    def update_calls(self, call_ids: List[Text], values_to_update: Dict[Text, Any]) -> None:
+    def update_calls(self, call_ids: List[str], values_to_update: Dict[str, Any]) -> None:
         hubspot = self.handler.connect()
         calls_to_update = [HubSpotObjectBatchInput(id=cid, properties=values_to_update) for cid in call_ids]
         batch_input = BatchInputSimplePublicObjectBatchInput(inputs=calls_to_update)
@@ -3082,7 +3093,7 @@ def update_calls(self, call_ids: List[Text], values_to_update: Dict[Text, Any])
         except Exception as e:
             raise Exception(f"Calls update failed {e}")
 
-    def delete_calls(self, call_ids: List[Text]) -> None:
+    def delete_calls(self, call_ids: List[str]) -> None:
         hubspot = self.handler.connect()
         calls_to_delete = [HubSpotObjectId(id=cid) for cid in call_ids]
         batch_input = BatchInputSimplePublicObjectId(inputs=calls_to_delete)
@@ -3180,7 +3191,7 @@ def remove(self, conditions: List[FilterCondition]) -> None:
         logger.info(f"Deleting {len(email_ids)} email(s) matching WHERE conditions")
         self.delete_emails(email_ids)
 
-    def get_columns(self) -> List[Text]:
+    def get_columns(self) -> List[str]:
         return self._get_default_email_columns()
 
     @staticmethod
@@ -3293,7 +3304,7 @@ def _email_to_dict(
             row = enrich_object_with_associations(email, "emails", row)
         return row
 
-    def create_emails(self, emails_data: List[Dict[Text, Any]]) -> None:
+    def create_emails(self, emails_data: List[Dict[str, Any]]) -> None:
         if not emails_data:
             raise ValueError("No email data provided for creation")
 
@@ -3314,7 +3325,7 @@ def create_emails(self, emails_data: List[Dict[Text, Any]]) -> None:
             logger.error(f"Emails creation failed: {str(e)}")
             raise Exception(f"Emails creation failed {e}")
 
-    def update_emails(self, email_ids: List[Text], values_to_update: Dict[Text, Any]) -> None:
+    def update_emails(self, email_ids: List[str], values_to_update: Dict[str, Any]) -> None:
         hubspot = self.handler.connect()
         emails_to_update = [HubSpotObjectBatchInput(id=eid, properties=values_to_update) for eid in email_ids]
         batch_input = BatchInputSimplePublicObjectBatchInput(inputs=emails_to_update)
@@ -3326,7 +3337,7 @@ def update_emails(self, email_ids: List[Text], values_to_update: Dict[Text, Any]
         except Exception as e:
             raise Exception(f"Emails update failed {e}")
 
-    def delete_emails(self, email_ids: List[Text]) -> None:
+    def delete_emails(self, email_ids: List[str]) -> None:
         hubspot = self.handler.connect()
         emails_to_delete = [HubSpotObjectId(id=eid) for eid in email_ids]
         batch_input = BatchInputSimplePublicObjectId(inputs=emails_to_delete)
@@ -3424,7 +3435,7 @@ def remove(self, conditions: List[FilterCondition]) -> None:
         logger.info(f"Deleting {len(meeting_ids)} meeting(s) matching WHERE conditions")
         self.delete_meetings(meeting_ids)
 
-    def get_columns(self) -> List[Text]:
+    def get_columns(self) -> List[str]:
         return self._get_default_meeting_columns()
 
     @staticmethod
@@ -3537,7 +3548,7 @@ def _meeting_to_dict(
             row = enrich_object_with_associations(meeting, "meetings", row)
         return row
 
-    def create_meetings(self, meetings_data: List[Dict[Text, Any]]) -> None:
+    def create_meetings(self, meetings_data: List[Dict[str, Any]]) -> None:
         if not meetings_data:
             raise ValueError("No meeting data provided for creation")
 
@@ -3558,7 +3569,7 @@ def create_meetings(self, meetings_data: List[Dict[Text, Any]]) -> None:
             logger.error(f"Meetings creation failed: {str(e)}")
             raise Exception(f"Meetings creation failed {e}")
 
-    def update_meetings(self, meeting_ids: List[Text], values_to_update: Dict[Text, Any]) -> None:
+    def update_meetings(self, meeting_ids: List[str], values_to_update: Dict[str, Any]) -> None:
         hubspot = self.handler.connect()
         meetings_to_update = [HubSpotObjectBatchInput(id=mid, properties=values_to_update) for mid in meeting_ids]
         batch_input = BatchInputSimplePublicObjectBatchInput(inputs=meetings_to_update)
@@ -3570,7 +3581,7 @@ def update_meetings(self, meeting_ids: List[Text], values_to_update: Dict[Text,
         except Exception as e:
             raise Exception(f"Meetings update failed {e}")
 
-    def delete_meetings(self, meeting_ids: List[Text]) -> None:
+    def delete_meetings(self, meeting_ids: List[str]) -> None:
         hubspot = self.handler.connect()
         meetings_to_delete = [HubSpotObjectId(id=mid) for mid in meeting_ids]
         batch_input = BatchInputSimplePublicObjectId(inputs=meetings_to_delete)
@@ -3668,7 +3679,7 @@ def remove(self, conditions: List[FilterCondition]) -> None:
         logger.info(f"Deleting {len(note_ids)} note(s) matching WHERE conditions")
         self.delete_notes(note_ids)
 
-    def get_columns(self) -> List[Text]:
+    def get_columns(self) -> List[str]:
         return self._get_default_note_columns()
 
     @staticmethod
@@ -3776,7 +3787,7 @@ def _note_to_dict(
             row = enrich_object_with_associations(note, "notes", row)
         return row
 
-    def create_notes(self, notes_data: List[Dict[Text, Any]]) -> None:
+    def create_notes(self, notes_data: List[Dict[str, Any]]) -> None:
         if not notes_data:
             raise ValueError("No note data provided for creation")
 
@@ -3797,7 +3808,7 @@ def create_notes(self, notes_data: List[Dict[Text, Any]]) -> None:
             logger.error(f"Notes creation failed: {str(e)}")
             raise Exception(f"Notes creation failed {e}")
 
-    def update_notes(self, note_ids: List[Text], values_to_update: Dict[Text, Any]) -> None:
+    def update_notes(self, note_ids: List[str], values_to_update: Dict[str, Any]) -> None:
         hubspot = self.handler.connect()
         notes_to_update = [HubSpotObjectBatchInput(id=nid, properties=values_to_update) for nid in note_ids]
         batch_input = BatchInputSimplePublicObjectBatchInput(inputs=notes_to_update)
@@ -3809,7 +3820,7 @@ def update_notes(self, note_ids: List[Text], values_to_update: Dict[Text, Any])
         except Exception as e:
             raise Exception(f"Notes update failed {e}")
 
-    def delete_notes(self, note_ids: List[Text]) -> None:
+    def delete_notes(self, note_ids: List[str]) -> None:
         hubspot = self.handler.connect()
         notes_to_delete = [HubSpotObjectId(id=nid) for nid in note_ids]
         batch_input = BatchInputSimplePublicObjectId(inputs=notes_to_delete)
@@ -3818,3 +3829,243 @@ def delete_notes(self, note_ids: List[Text]) -> None:
             logger.info("Notes deleted")
         except Exception as e:
             raise Exception(f"Notes deletion failed {e}")
+
+
+class LeadsTable(HubSpotAPIResource):
+    """HubSpot Leads table for prospective customer records."""
+
+    # Reference: https://developers.hubspot.com/docs/api-reference/crm-leads-v3/guide
+    SEARCHABLE_COLUMNS: Set[str] = {"hs_lead_name", "hs_lead_type", "hs_lead_label", "id"}
+    ASSOCIATION_COLUMNS = {"primary_contact_id", "primary_company_id"}
+
+    def meta_get_tables(self, table_name: str) -> Dict[str, Any]:
+        row_count = None
+        try:
+            self.handler.connect()
+            row_count = self.handler._estimate_table_rows("leads")
+        except Exception as e:
+            logger.warning(f"Could not estimate HubSpot leads row count: {e}")
+        return {
+            "TABLE_NAME": "leads",
+            "TABLE_TYPE": "BASE TABLE",
+            "TABLE_DESCRIPTION": "HubSpot leads representing prospective customer records",
+            "ROW_COUNT": row_count,
+        }
+
+    def meta_get_columns(self, table_name: str) -> List[Dict[str, Any]]:
+        return self.handler._get_default_meta_columns("leads")
+
+    def list(
+        self,
+        conditions: List[FilterCondition] = None,
+        limit: int = None,
+        sort: List[SortColumn] = None,
+        targets: List[str] = None,
+        search_filters: Optional[List[Dict[str, Any]]] = None,
+        search_sorts: Optional[List[Dict[str, Any]]] = None,
+        allow_search: bool = True,
+    ) -> pd.DataFrame:
+        leads_df = pd.json_normalize(
+            self.get_leads(
+                limit=limit,
+                where_conditions=conditions,
+                properties=targets,
+                search_filters=search_filters,
+                search_sorts=search_sorts,
+                allow_search=allow_search,
+            )
+        )
+        if leads_df.empty:
+            leads_df = pd.DataFrame(columns=targets or self._get_default_lead_columns())
+        return leads_df
+
+    def add(self, lead_data: List[dict]):
+        self.create_leads(lead_data)
+
+    def modify(self, conditions: List[FilterCondition], values: Dict) -> None:
+        normalized_conditions = _normalize_filter_conditions(conditions)
+        leads_df = pd.json_normalize(self.get_leads(limit=200, where_conditions=normalized_conditions))
+
+        if leads_df.empty:
+            raise ValueError("No leads retrieved from HubSpot to evaluate update conditions.")
+
+        executor_conditions = _normalize_conditions_for_executor(normalized_conditions)
+        update_query_executor = UPDATEQueryExecutor(leads_df, executor_conditions)
+        filtered_df = update_query_executor.execute_query()
+
+        if filtered_df.empty:
+            raise ValueError(f"No leads found matching WHERE conditions: {conditions}.")
+
+        lead_ids = filtered_df["id"].astype(str).tolist()
+        logger.info(f"Updating {len(lead_ids)} lead(s) matching WHERE conditions")
+        self.update_leads(lead_ids, values)
+
+    def remove(self, conditions: List[FilterCondition]) -> None:
+        normalized_conditions = _normalize_filter_conditions(conditions)
+        leads_df = pd.json_normalize(self.get_leads(limit=200, where_conditions=normalized_conditions))
+
+        if leads_df.empty:
+            raise ValueError("No leads retrieved from HubSpot to evaluate delete conditions.")
+
+        executor_conditions = _normalize_conditions_for_executor(normalized_conditions)
+        delete_query_executor = DELETEQueryExecutor(leads_df, executor_conditions)
+        filtered_df = delete_query_executor.execute_query()
+
+        if filtered_df.empty:
+            raise ValueError(f"No leads found matching WHERE conditions: {conditions}.")
+
+        lead_ids = filtered_df["id"].astype(str).tolist()
+        logger.info(f"Deleting {len(lead_ids)} lead(s) matching WHERE conditions")
+        self.delete_leads(lead_ids)
+
+    def get_columns(self) -> List[str]:
+        return self._get_default_lead_columns()
+
+    @staticmethod
+    def _get_default_lead_columns() -> List[str]:
+        return [
+            "id",
+            "hs_lead_name",
+            "hs_lead_type",
+            "hs_lead_label",
+            "hubspot_owner_id",
+            "hs_timestamp",
+            "primary_contact_id",
+            "primary_company_id",
+            "createdate",
+            "lastmodifieddate",
+        ]
+
+    def get_leads(
+        self,
+        limit: Optional[int] = None,
+        where_conditions: Optional[List] = None,
+        properties: Optional[List[str]] = None,
+        search_filters: Optional[List[Dict[str, Any]]] = None,
+        search_sorts: Optional[List[Dict[str, Any]]] = None,
+        allow_search: bool = True,
+        **kwargs,
+    ) -> List[Dict]:
+        normalized_conditions = _normalize_filter_conditions(where_conditions)
+        hubspot = self.handler.connect()
+
+        requested_properties = properties or []
+        default_properties = self._get_default_lead_columns()
+        columns = requested_properties or default_properties
+        association_targets, hubspot_columns = _prepare_association_request("leads", columns)
+        hubspot_properties = _build_hubspot_properties(hubspot_columns)
+
+        api_kwargs = {**kwargs, "properties": hubspot_properties}
+        if limit is not None:
+            api_kwargs["limit"] = limit
+        else:
+            api_kwargs.pop("limit", None)
+        if association_targets:
+            api_kwargs["associations"] = association_targets
+
+        if allow_search and (search_filters or search_sorts or normalized_conditions):
+            filters = search_filters
+            if filters is None and normalized_conditions:
+                filters = _build_hubspot_search_filters(normalized_conditions, self.SEARCHABLE_COLUMNS)
+            if filters is not None or search_sorts is not None:
+                if association_targets:
+                    logger.debug("HubSpot search API does not include associations for leads.")
+                search_results = self._search_leads_by_conditions(
+                    hubspot,
+                    filters,
+                    hubspot_properties,
+                    limit,
+                    search_sorts,
+                    hubspot_columns,
+                    association_targets,
+                )
+                logger.info(f"Retrieved {len(search_results)} leads from HubSpot via search API")
+                return search_results
+
+        leads = self.handler._get_objects_all("leads", **api_kwargs)
+        leads_dict = []
+        for lead in leads:
+            try:
+                row = self._lead_to_dict(lead, hubspot_columns, association_targets)
+                leads_dict.append(row)
+            except Exception as e:
+                logger.warning(f"Error processing lead {getattr(lead, 'id', 'unknown')}: {str(e)}")
+                continue
+
+        logger.info(f"Retrieved {len(leads_dict)} leads from HubSpot")
+        return leads_dict
+
+    def _search_leads_by_conditions(
+        self,
+        hubspot: HubSpot,
+        filters: Optional[List[Dict[str, Any]]],
+        properties: List[str],
+        limit: Optional[int],
+        sorts: Optional[List[Dict[str, Any]]],
+        columns: List[str],
+        association_targets: List[str],
+    ) -> List[Dict[str, Any]]:
+        return _execute_hubspot_search(
+            hubspot.crm.objects.search_api,
+            filters or [],
+            properties,
+            limit,
+            lambda obj: self._lead_to_dict(obj, columns, association_targets),
+            sorts=sorts,
+            object_type="leads",
+        )
+
+    def _lead_to_dict(
+        self,
+        lead: Any,
+        columns: Optional[List[str]] = None,
+        association_targets: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        columns = columns or self._get_default_lead_columns()
+        row = self._object_to_dict(lead, columns)
+        if association_targets:
+            row = enrich_object_with_associations(lead, "leads", row)
+        return row
+
+    def create_leads(self, leads_data: List[Dict[str, Any]]) -> None:
+        if not leads_data:
+            raise ValueError("No lead data provided for creation")
+
+        logger.info(f"Attempting to create {len(leads_data)} lead(s)")
+        hubspot = self.handler.connect()
+        leads_to_create = [HubSpotObjectInputCreate(properties=lead) for lead in leads_data]
+        batch_input = BatchInputSimplePublicObjectBatchInputForCreate(inputs=leads_to_create)
+
+        try:
+            created_leads = hubspot.crm.objects.leads.batch_api.create(
+                batch_input_simple_public_object_batch_input_for_create=batch_input
+            )
+            if not created_leads or not hasattr(created_leads, "results") or not created_leads.results:
+                raise Exception("Lead creation returned no results")
+            created_ids = [lead.id for lead in created_leads.results]
+            logger.info(f"Successfully created {len(created_ids)} lead(s) with IDs: {created_ids}")
+        except Exception as e:
+            logger.error(f"Leads creation failed: {str(e)}")
+            raise Exception(f"Leads creation failed {e}")
+
+    def update_leads(self, lead_ids: List[str], values_to_update: Dict[str, Any]) -> None:
+        hubspot = self.handler.connect()
+        leads_to_update = [HubSpotObjectBatchInput(id=lid, properties=values_to_update) for lid in lead_ids]
+        batch_input = BatchInputSimplePublicObjectBatchInput(inputs=leads_to_update)
+        try:
+            updated = hubspot.crm.objects.leads.batch_api.update(
+                batch_input_simple_public_object_batch_input=batch_input
+            )
+            logger.info(f"Leads with ID {[lead.id for lead in updated.results]} updated")
+        except Exception as e:
+            raise Exception(f"Leads update failed {e}")
+
+    def delete_leads(self, lead_ids: List[str]) -> None:
+        hubspot = self.handler.connect()
+        leads_to_delete = [HubSpotObjectId(id=lid) for lid in lead_ids]
+        batch_input = BatchInputSimplePublicObjectId(inputs=leads_to_delete)
+        try:
+            hubspot.crm.objects.leads.batch_api.archive(batch_input_simple_public_object_id=batch_input)
+            logger.info("Leads deleted")
+        except Exception as e:
+            raise Exception(f"Leads deletion failed {e}")
diff --git a/mindsdb/integrations/handlers/huggingface_handler/requirements.txt b/mindsdb/integrations/handlers/huggingface_handler/requirements.txt
index b70a302214c..eae77291d1f 100644
--- a/mindsdb/integrations/handlers/huggingface_handler/requirements.txt
+++ b/mindsdb/integrations/handlers/huggingface_handler/requirements.txt
@@ -1,7 +1,7 @@
 # NOTE: Any changes made here need to be made to requirements_cpu.txt as well
 datasets==2.16.1
 evaluate==0.4.3
-nltk==3.9.1
-huggingface-hub==0.29.3
+nltk==3.9.3
+huggingface-hub==1.9.1
 torch==2.8.0
-transformers >= 4.42.4
+transformers==5.5.0
diff --git a/mindsdb/integrations/handlers/huggingface_handler/requirements_cpu.txt b/mindsdb/integrations/handlers/huggingface_handler/requirements_cpu.txt
index 7a4e0de6084..b509a2942f4 100644
--- a/mindsdb/integrations/handlers/huggingface_handler/requirements_cpu.txt
+++ b/mindsdb/integrations/handlers/huggingface_handler/requirements_cpu.txt
@@ -1,7 +1,7 @@
 # Needs to be installed with `pip install --extra-index-url https://download.pytorch.org/whl/ .[huggingface_cpu]`
 datasets==2.16.1
 evaluate==0.4.3
-nltk==3.9.1
-huggingface-hub==0.29.3
+nltk==3.9.3
+huggingface-hub==1.9.1
 torch==2.8.0+cpu
-transformers >= 4.42.4
\ No newline at end of file
+transformers==5.5.0
diff --git a/mindsdb/integrations/handlers/instatus_handler/README.md b/mindsdb/integrations/handlers/instatus_handler/README.md
index f6b2a098a77..be8ef54a595 100644
--- a/mindsdb/integrations/handlers/instatus_handler/README.md
+++ b/mindsdb/integrations/handlers/instatus_handler/README.md
@@ -92,7 +92,7 @@ WHERE id = '<status-page-id>';
 
 ```sql
 INSERT INTO mindsdb_instatus.status_pages (email, name, subdomain, components, logoUrl, faviconUrl, websiteUrl, language, useLargeHeader, brandColor, okColor, disruptedColor, degradedColor, downColor, noticeColor, unknownColor, googleAnalytics, subscribeBySms, smsService, twilioSid, twilioToken, twilioSender, nexmoKey, nexmoSecret, nexmoSender, htmlInMeta, htmlAboveHeader, htmlBelowHeader, htmlAboveFooter, htmlBelowFooter, htmlBelowSummary, cssGlobal, launchDate, dateFormat, dateFormatShort, timeFormat)
-VALUES ('yourname@gmail.com', 'mindsdb', 'mindsdb-instatus', '["Website", "App", "API"]', 'https://instatus.com/sample.png', 'https://instatus.com/favicon-32x32.png', 'https://instatus.com', 'en', true, '#111', '#33B17E', '#FF8C03', '#ECC94B', '#DC123D', '#70808F', '#DFE0E1', 'UA-00000000-1', true, 'twilio', 'YOUR_TWILIO_SID', 'YOUR_TWILIO_TOKEN', 'YOUR_TWILIO_SENDER', null, null, null, null, null, null, null, null, null, null, null, 'MMMMMM d, yyyy', 'MMM yyyy', 'p');
+VALUES ('yourname@gmail.com', 'mindsdb', 'mindsdb-instatus', '["Website", "App", "API"]', 'https://instatus.com/sample.png', 'https://instatus.com/favicon-32x32.png', 'https://instatus.com', 'en', 'true', '#111', '#33B17E', '#FF8C03', '#ECC94B', '#DC123D', '#70808F', '#DFE0E1', 'UA-00000000-1', 'true', 'twilio', 'YOUR_TWILIO_SID', 'YOUR_TWILIO_TOKEN', 'YOUR_TWILIO_SENDER', null, null, null, null, null, null, null, null, null, null, null, 'MMMMMM d, yyyy', 'MMM yyyy', 'p');
 ```
 
 Note:
diff --git a/mindsdb/integrations/handlers/jira_handler/README.md b/mindsdb/integrations/handlers/jira_handler/README.md
index 99820fcb842..cee817d49d1 100644
--- a/mindsdb/integrations/handlers/jira_handler/README.md
+++ b/mindsdb/integrations/handlers/jira_handler/README.md
@@ -11,7 +11,7 @@ The integration allows MindsDB to access data from Jira and enhance it with AI c
 Before proceeding, ensure the following prerequisites are met:
 
 1. Install MindsDB locally via [Docker](https://docs.mindsdb.com/setup/self-hosted/docker) or [Docker Desktop](https://docs.mindsdb.com/setup/self-hosted/docker-desktop).
-2. To connect Salesforce to MindsDB, install the required dependencies following [this instruction](https://docs.mindsdb.com/setup/self-hosted/docker#install-dependencies).
+2. To connect Jira to MindsDB, install the required dependencies following [this instruction](https://docs.mindsdb.com/setup/self-hosted/docker#install-dependencies).
 
 ## Connection
 
@@ -22,33 +22,79 @@ CREATE DATABASE jira_datasource
 WITH
     ENGINE = 'jira',
     PARAMETERS = {
-        "url": "https://example.atlassian.net",
-        "username": "john.doe@example.com",
-        "api_token": "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
+        "jira_url": "https://example.atlassian.net",
+        "jira_username": "john.doe@example.com",
+        "jira_api_token": "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6",
+        "cloud": true
     };
 ```
 
 Required connection parameters include the following:
 
-* `url`: The base URL for your Jira instance/server.
-* `username`: The email address associated with your Jira account.
-* `api_token`: The API token generated for your Jira account.
+* `jira_url`: The base URL for your Jira instance/server.
+* `jira_username`: The email address associated with your Jira account.
+* `jira_api_token`: The API token generated for your Jira Cloud account.
 * `cloud`: (Optional) Set to `true` for Jira Cloud or `false` for Jira Server. Defaults to `true`.
 
+For Jira Server connections, set `cloud` to `false` and use either:
+
+* `jira_personal_access_token`: A Jira Server personal access token, or
+* `jira_password`: With `jira_username`, for basic authentication.
+
+Example for Jira Server using a personal access token:
+
+```sql
+CREATE DATABASE jira_server
+WITH
+    ENGINE = 'jira',
+    PARAMETERS = {
+        "jira_url": "https://jira.my-company.internal",
+        "jira_username": "john.doe@example.com",
+        "jira_personal_access_token": "server-personal-access-token",
+        "cloud": false
+    };
+```
+
 <Tip>
 Refer this [guide](https://support.atlassian.com/atlassian-account/docs/manage-api-tokens-for-your-atlassian-account/) for instructions on how to create API tokens for your account.
 </Tip>
 
 ## Usage
 
-Retrieve data from a specified table by providing the integration and table names:
+The integration exposes the following tables:
+
+* `projects`: Jira projects accessible to the connection.
+* `issues`: Normalized issue data, including summary, description, status, priority, assignee, and timestamps.
+* `attachments`: Attachments for the fetched issues.
+* `comments`: Comments for the fetched issues.
+* `users`: Jira users available to the current context.
+* `groups`: Jira user groups.
+
+Query a table by providing the integration and table names:
 
 ```sql
 SELECT *
-FROM jira_datasource.table_name
+FROM jira_datasource.issues
 LIMIT 10;
 ```
 
+Filter by issue or project identifiers to reduce API calls:
+
+```sql
+SELECT key, summary, status, assignee
+FROM jira_datasource.issues
+WHERE project_key = 'ENG'
+LIMIT 20;
+```
+
+Fetch related attachments or comments for a specific issue:
+
+```sql
+SELECT filename, content_url, created
+FROM jira_datasource.attachments
+WHERE issue_key = 'ENG-123';
+```
+
 <Note>
-The above example utilize `jira_datasource` as the datasource name, which is defined in the `CREATE DATABASE` command.
-</Note>
\ No newline at end of file
+The above examples utilize `jira_datasource` as the datasource name, which is defined in the `CREATE DATABASE` command.
+</Note>
diff --git a/mindsdb/integrations/handlers/jira_handler/__about__.py b/mindsdb/integrations/handlers/jira_handler/__about__.py
index acf2f75edae..e014cc9b5e9 100644
--- a/mindsdb/integrations/handlers/jira_handler/__about__.py
+++ b/mindsdb/integrations/handlers/jira_handler/__about__.py
@@ -1,9 +1,9 @@
-__title__ = 'MindsDB Jira handler'
-__package_name__ = 'mindsdb_jira_handler'
-__version__ = '0.0.2'
+__title__ = "MindsDB Jira handler"
+__package_name__ = "mindsdb_jira_handler"
+__version__ = "0.0.3"
 __description__ = "MindsDB handler for Jira"
-__author__ = 'Balaji Seetharaman'
-__github__ = 'https://github.com/mindsdb/mindsdb'
-__pypi__ = 'https://pypi.org/project/mindsdb/'
-__license__ = 'MIT'
-__copyright__ = 'Copyright 2022- mindsdb'
+__authors__ = "Balaji Seetharaman, Konstantin Sivakov"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2022- mindsdb"
diff --git a/mindsdb/integrations/handlers/jira_handler/connection_args.py b/mindsdb/integrations/handlers/jira_handler/connection_args.py
new file mode 100644
index 00000000000..5d4d2182a8a
--- /dev/null
+++ b/mindsdb/integrations/handlers/jira_handler/connection_args.py
@@ -0,0 +1,52 @@
+from collections import OrderedDict
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+connection_args = OrderedDict(
+    jira_url={
+        "type": ARG_TYPE.STR,
+        "description": "The URL of the Jira instance (e.g., https://your-domain.atlassian.net).",
+        "required": True,
+        "label": "Jira URL",
+    },
+    jira_username={
+        "type": ARG_TYPE.STR,
+        "description": "The username or email address used to authenticate with Jira.",
+        "required": True,
+        "label": "Username",
+    },
+    jira_password={
+        "type": ARG_TYPE.PWD,
+        "description": "The password used for authentication with Jira (alternative to API token).",
+        "required": False,
+        "label": "Password",
+        "secret": True,
+    },
+    jira_personal_access_token={
+        "type": ARG_TYPE.PWD,
+        "description": "The personal access token used for authentication with Jira (alternative to API token).",
+        "required": False,
+        "label": "Personal Access Token",
+        "secret": True,
+    },
+    jira_api_token={
+        "type": ARG_TYPE.PWD,
+        "description": "The API token used for authentication with Jira.",
+        "required": True,
+        "label": "API Token",
+        "secret": True,
+    },
+    jira_cloud={
+        "type": ARG_TYPE.BOOL,
+        "description": "Indicates whether to connect to Jira Cloud (True) or Jira Server (False). Default is True.",
+        "required": False,
+        "label": "Jira Cloud",
+    },
+)
+
+connection_args_example = OrderedDict(
+    jira_url="https://your-domain.atlassian.net",
+    jira_username="user@example.com",
+    jira_api_token="YOUR_API_TOKEN",
+    jira_cloud=True,
+)
diff --git a/mindsdb/integrations/handlers/jira_handler/jira_handler.py b/mindsdb/integrations/handlers/jira_handler/jira_handler.py
index 4964cfd9a0f..007f142115e 100644
--- a/mindsdb/integrations/handlers/jira_handler/jira_handler.py
+++ b/mindsdb/integrations/handlers/jira_handler/jira_handler.py
@@ -1,15 +1,18 @@
-from typing import Any, Dict
+from typing import Any, Dict, Type, Optional
 
 from atlassian import Jira
 from requests.exceptions import HTTPError
 
 from mindsdb.integrations.handlers.jira_handler.jira_tables import (
-    JiraProjectsTable,
+    JiraAttachmentsTable,
+    JiraCommentsTable,
+    JiraGroupsTable,
     JiraIssuesTable,
+    JiraProjectsTable,
     JiraUsersTable,
-    JiraGroupsTable,
 )
-from mindsdb.integrations.libs.api_handler import APIHandler
+
+from mindsdb.integrations.libs.api_handler import MetaAPIHandler
 from mindsdb.integrations.libs.response import (
     HandlerResponse as Response,
     HandlerStatusResponse as StatusResponse,
@@ -20,8 +23,71 @@
 
 logger = log.getLogger(__name__)
 
+DEFAULT_TABLES = ["projects", "issues", "users", "groups", "attachments", "comments"]
+
 
-class JiraHandler(APIHandler):
+def _normalize_cloud_credentials(connection_data: Dict[str, Any]) -> Dict[str, Any]:
+    """Normalizes credentials for Jira Cloud connections.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the normalized credentials.
+    """
+    if "jira_username" not in connection_data or "jira_api_token" not in connection_data:
+        raise ValueError(
+            "For Jira Cloud, both 'jira_username' and 'jira_api_token' parameters are required in the connection data."
+        )
+
+    return {
+        "username": connection_data["jira_username"],
+        "api_token": connection_data["jira_api_token"],
+    }
+
+
+def _normalize_server_credentials(connection_data: Dict[str, Any]) -> Dict[str, Any]:
+    """Normalizes credentials for Jira Server connections.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the normalized credentials.
+    """
+    if "jira_personal_access_token" in connection_data:
+        return {"personal_access_token": connection_data["jira_personal_access_token"]}
+
+    if "jira_username" in connection_data and "jira_password" in connection_data:
+        return {
+            "username": connection_data["jira_username"],
+            "password": connection_data["jira_password"],
+        }
+
+    raise ValueError(
+        "For Jira Server, either 'jira_personal_access_token' or both 'jira_username' and 'jira_password' parameters are required in the connection data."
+    )
+
+
+def normalize_jira_connection_data(connection_data: Dict[str, Any]) -> Dict[str, Any]:
+    """Normalizes the connection data for Jira connections.
+    Returns:
+        Dict[str, Any]: A dictionary containing the normalized connection data.
+    """
+    if "jira_url" not in connection_data:
+        raise ValueError("The 'jira_url' parameter is required in the connection data.")
+
+    cloud = bool(connection_data.get("jira_cloud", False))
+
+    if cloud:
+        logger.debug("Normalizing connection data for Jira Cloud.")
+        credentials = _normalize_cloud_credentials(connection_data)
+    else:
+        logger.debug("Normalizing connection data for Jira Server.")
+        credentials = _normalize_server_credentials(connection_data)
+
+    return {
+        "url": connection_data["jira_url"],
+        "cloud": cloud,
+        **credentials,
+    }
+
+
+class JiraHandler(MetaAPIHandler):
     """
     This handler handles the connection and execution of SQL statements on Jira.
     """
@@ -36,16 +102,30 @@ def __init__(self, name: str, connection_data: Dict, **kwargs: Any) -> None:
             kwargs: Arbitrary keyword arguments.
         """
         super().__init__(name)
-        self.connection_data = connection_data
+        self.connection_data = self._normalize_connection_data(connection_data)
         self.kwargs = kwargs
 
-        self.connection = None
-        self.is_connected = False
-
-        self._register_table("projects", JiraProjectsTable(self))
-        self._register_table("issues", JiraIssuesTable(self))
-        self._register_table("groups", JiraGroupsTable(self))
-        self._register_table("users", JiraUsersTable(self))
+        self.connection: Optional[Jira] = None
+        self.is_connected: bool = False
+
+        table_factories: Dict[str, Type] = {
+            "projects": JiraProjectsTable,
+            "issues": JiraIssuesTable,
+            "groups": JiraGroupsTable,
+            "users": JiraUsersTable,
+            "attachments": JiraAttachmentsTable,
+            "comments": JiraCommentsTable,
+        }
+        for table in DEFAULT_TABLES:
+            table_name = table.lower()
+            table_class = table_factories.get(table_name)
+            if table_class is None:
+                logger.warning(f"Skipping unsupported Jira table '{table}'.")
+                continue
+            self._register_table(table_name, table_class(self))
+
+    def _normalize_connection_data(self, connection_data: Dict) -> Dict:
+        return normalize_jira_connection_data(connection_data)
 
     def connect(self) -> Jira:
         """
@@ -59,7 +139,10 @@ def connect(self) -> Jira:
             atlassian.jira.Jira: A connection object to the Jira API.
         """
         if self.is_connected is True:
-            return self.connection
+            if self.connection is not None:
+                return self.connection
+            else:
+                raise RuntimeError("Jira connection is not established.")
 
         is_cloud = self.connection_data.get("cloud", True)
 
@@ -75,14 +158,17 @@ def connect(self) -> Jira:
                 "cloud": is_cloud,
             }
         else:
-            # Jira Server supports personal access token authentication or open access.
+            # Jira Server
             if "url" not in self.connection_data:
                 raise ValueError("Required parameter 'url' must be provided.")
 
             config = {"url": self.connection_data["url"], "cloud": False}
 
             if "personal_access_token" in self.connection_data:
-                config["session"] = {"Authorization": f"Bearer {self.connection_data['personal_access_token']}"}
+                config["token"] = self.connection_data["personal_access_token"]
+            elif "username" in self.connection_data and "password" in self.connection_data:
+                config["username"] = self.connection_data["username"]
+                config["password"] = self.connection_data["password"]
 
         try:
             self.connection = Jira(**config)
@@ -118,7 +204,22 @@ def check_connection(self) -> StatusResponse:
 
     def native_query(self, query: str) -> Response:
         """
-        Executes a native JQL query on Jira and returns the result.
+        Execute a native JQL query and return the result as rows from the `issues` table.
+
+        This uses Jira's issue search endpoint, which always returns an `issues` array,
+        so native_query is intentionally *issue-centric* and does not return projects,
+        users, or groups directly.
+
+        For JQL Cloud REST endpoints and behavior, see:
+        - JQL REST API group:
+        https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-jql/
+        - Issue search using JQL:
+        https://developer.atlassian.com/cloud/jira/platform/rest/v3/api-group-issue-search/
+
+        For Jira Server REST endpoints and behavior, see:
+        - JQL REST API group:
+        https://developer.atlassian.com/server/jira/platform/rest/v11002/api-group-jql/#api-group-jql
+
 
         Args:
             query (Text): The JQL query to be executed.
@@ -129,8 +230,11 @@ def native_query(self, query: str) -> Response:
         connection = self.connect()
 
         try:
+            logger.debug(f"Running query: {query} on Jira.")
             results = connection.jql(query)
-            df = JiraIssuesTable(self).normalize(results["issues"])
+            issues = results.get("issues", [])
+            issues_table = JiraIssuesTable(self)
+            df = issues_table.normalize(issues)
             response = Response(RESPONSE_TYPE.TABLE, df)
         except HTTPError as http_error:
             logger.error(f"Error running query: {query} on Jira, {http_error}!")
diff --git a/mindsdb/integrations/handlers/jira_handler/jira_tables.py b/mindsdb/integrations/handlers/jira_handler/jira_tables.py
index cfff87ce38c..f433aa97fda 100644
--- a/mindsdb/integrations/handlers/jira_handler/jira_tables.py
+++ b/mindsdb/integrations/handlers/jira_handler/jira_tables.py
@@ -1,28 +1,72 @@
-from typing import List, Optional
+# mindsdb/integrations/handlers/jira_handler/jira_tables.py
+
+from typing import Any, Dict, Iterable, List, Optional, Tuple
 
 from atlassian import Jira
 import pandas as pd
+from requests.exceptions import HTTPError
 
 from mindsdb.integrations.libs.api_handler import APIResource
-from mindsdb.integrations.utilities.sql_utils import FilterCondition, SortColumn, FilterOperator
+from mindsdb.integrations.utilities.sql_utils import (
+    FilterCondition,
+    SortColumn,
+    FilterOperator,
+)
 from mindsdb.utilities import log
 
 
 logger = log.getLogger(__name__)
 
+SERVER_COLUMNS = [
+    "key",
+    "name",
+    "emailAddress",
+    "displayName",
+    "active",
+    "timeZone",
+    "locale",
+    "lastLoginTime",
+    "applicationRoles",
+    "avatarUrls",
+    "groups",
+    "deleted",
+    "expand",
+]
+CLOUD_COLUMNS = [
+    "accountId",
+    "accountType",
+    "emailAddress",
+    "displayName",
+    "active",
+    "timeZone",
+    "locale",
+    "applicationRoles",
+    "avatarUrls",
+    "groups",
+]
+
 
 class JiraTableBase(APIResource):
-    """Base class for Jira tables"""
+    """
+    Base class for Jira tables.
+
+    Provides a helper for converting API records to a DataFrame
+    with a fixed set of columns.
+    """
+
+    def __init__(self, handler: Any) -> None:
+        super().__init__(handler)
+        self.handler = handler
 
     def to_dataframe(self, records: Optional[List[dict]]) -> pd.DataFrame:
         """
         Convert records to DataFrame with fixed columns, handling missing optional fields.
 
         Args:
-            records: List of record dictionaries from Jira API, or None/empty list
+            records: List of record dictionaries from Jira API, or None/empty list.
 
         Returns:
-            DataFrame with all expected columns, missing fields filled with None
+            DataFrame with all expected columns, missing fields filled with None.
         """
         if records:
             df = pd.DataFrame(records)
@@ -32,31 +76,266 @@ def to_dataframe(self, records: Optional[List[dict]]) -> pd.DataFrame:
         return df
 
 
-class JiraProjectsTable(JiraTableBase):
+class JiraIssueFetcherMixin:
+    """
+    Utility mixin to share issue fetching
+    logic between Jira issue-related tables:
+    - issues
+    - attachments
+    - comments
+    """
+
+    PROJECT_FIELDS = {"project_id", "project_key", "project_name", "project"}
+
+    def _fetch_issues(
+        self,
+        client: Jira,
+        conditions: Optional[List[FilterCondition]],
+        limit: Optional[int],
+    ) -> List[dict]:
+        issues: List[dict] = []
+        conditions = conditions or []
+
+        # Apply identifier or project-based filters
+        for condition in conditions:
+            if condition.column in ("id", "key", "issue_id", "issue_key"):
+                fetched = self._fetch_by_identifier(client, condition)
+                for issue in fetched:
+                    issues.append(issue)
+                condition.applied = True
+            elif condition.column in self.PROJECT_FIELDS:
+                project_ids = self._resolve_project_ids(client, condition.column, condition.value)
+                if len(project_ids) > 0:
+                    self._fetch_by_projects(client, project_ids, limit, issues)
+                    condition.applied = True
+
+        if not issues:
+            projects = self._get_all_projects(client)
+            project_ids = []
+            for project in projects:
+                project_id = project.get("id")
+                if project_id is not None:
+                    project_ids.append(project_id)
+            self._fetch_by_projects(client, project_ids, limit, issues)
+
+        return issues
+
+    def _fetch_by_identifier(self, client: Jira, condition: FilterCondition) -> List[dict]:
+        """
+        Fetch issues by id or key. For IN, we still call get_issue for each identifier.
+        """
+        if isinstance(condition.value, (list, tuple, set)):
+            values: Iterable = condition.value
+        else:
+            values = [condition.value]
+
+        issues: List[dict] = []
+
+        for identifier in values:
+            if condition.op in (FilterOperator.EQUAL, FilterOperator.IN):
+                issue = client.get_issue(identifier)
+                if isinstance(issue, dict):
+                    issues.append(issue)
+                else:
+                    logger.debug(
+                        "Skipping non-dict issue result for identifier %s: %s",
+                        identifier,
+                        type(issue).__name__,
+                    )
+            else:
+                raise ValueError(f"Unsupported operator {condition.op} for column {condition.column}.")
+
+        return issues
+
+    def _fetch_by_projects(
+        self,
+        client: Jira,
+        project_ids: Iterable[str],
+        limit: Optional[int],
+        current_issues: List[dict],
+    ) -> None:
+        """
+        Fetch issues by project, appending them to current_issues, and respecting the global limit.
+        """
+        for project_id in project_ids:
+            new_issues = self._get_project_issues_with_limit(
+                client,
+                project_id,
+                limit=limit,
+                current_issues=current_issues,
+            )
+            for issue in new_issues:
+                current_issues.append(issue)
+            if limit is not None and len(current_issues) >= limit:
+                break
+
+    def _resolve_project_ids(self, client: Jira, column: str, value: Any) -> List[str]:
+        """
+        Resolve project ids from project-id, project-key, or project-name based filter values.
+        """
+        projects = self._get_all_projects(client)
+
+        if isinstance(value, (list, tuple, set)):
+            values = value
+        else:
+            values = [value]
+
+        resolved_ids: List[str] = []
+
+        for val in values:
+            if column == "project_id":
+                resolved_ids.append(str(val))
+            elif column in ("project_key", "project"):
+                project = None
+                for p in projects:
+                    if p.get("key") == val:
+                        project = p
+                        break
+                if project is not None:
+                    resolved_ids.append(str(project.get("id")))
+                else:
+                    resolved_ids.append(str(val))
+            elif column == "project_name":
+                project = None
+                for p in projects:
+                    if p.get("name") == val:
+                        project = p
+                        break
+                if project is not None:
+                    resolved_ids.append(str(project.get("id")))
+            else:
+                resolved_ids.append(str(val))
+
+        return resolved_ids
+
+    def _get_all_projects(self, client: Jira) -> List[Dict]:
+        """
+        Cached list of all projects for the current handler connection.
+
+        Normalizes different Jira client return shapes (list or dict with 'projects'/'values')
+        and stores a list of project dicts in a cache attribute so the return type is always List[Dict].
+        """
+        if not hasattr(self, "_project_cache"):
+            resp = client.get_all_projects()
+            projects: List[Dict] = []
+
+            if isinstance(resp, list):
+                projects = resp
+            elif isinstance(resp, dict):
+                projects = resp.get("projects") or resp.get("values") or []
+                if projects is None:
+                    projects = []
+            else:
+                projects = []
+
+            self._project_cache = list(projects)
+
+        return self._project_cache
+
+    def _get_issue_field(self, client: Jira, issue: Dict, field_key: str) -> Any:
+        """
+        Robust helper to fetch a specific field for an issue.
+
+        If the field is not present in the issue's 'fields' dict, it will try
+        to refetch the issue with get_issue() and update the cache.
+        """
+        fields = issue.get("fields") or {}
+        if field_key in fields:
+            return fields[field_key]
+
+        issue_identifier = issue.get("id") or issue.get("key")
+        if issue_identifier is None:
+            logger.debug(
+                "Issue identifier missing, cannot fetch field '%s' for issue: %s",
+                field_key,
+                issue,
+            )
+            return None
+
+        try:
+            logger.debug(
+                "Fetching missing field '%s' for issue '%s'",
+                field_key,
+                issue_identifier,
+            )
+            refreshed_issue = client.get_issue(str(issue_identifier))
+        except Exception as issue_error:
+            logger.warning(
+                "Unable to fetch %s for issue %s: %s",
+                field_key,
+                issue_identifier,
+                issue_error,
+            )
+            return None
+
+        refreshed_fields = refreshed_issue.get("fields", {})
+        if "fields" not in issue or not isinstance(issue["fields"], dict):
+            issue["fields"] = {}
+        issue["fields"][field_key] = refreshed_fields.get(field_key)
+
+        return refreshed_fields.get(field_key)
+
+    def _get_project_issues_with_limit(
+        self,
+        client: Jira,
+        project_id: str,
+        limit: Optional[int] = None,
+        current_issues: Optional[List[dict]] = None,
+    ) -> List[dict]:
+        """
+        Helper to get issues from a project, respecting the global limit checkpoint.
+        """
+        if current_issues is None:
+            current_issues = []
+
+        if limit is not None:
+            remaining = limit - len(current_issues)
+            if remaining <= 0:
+                return []
+            issues = client.get_all_project_issues(project_id, limit=remaining)
+        else:
+            issues = client.get_all_project_issues(project_id)
+
+        return issues
+
+
+class JiraProjectsTable(JiraIssueFetcherMixin, JiraTableBase):
+    """
+    Projects table: provides project information for the Jira instance.
+    """
+
     def list(
         self,
         conditions: Optional[List[FilterCondition]] = None,
         limit: Optional[int] = None,
         sort: Optional[List[SortColumn]] = None,
         targets: Optional[List[str]] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> pd.DataFrame:
         client: Jira = self.handler.connect()
 
-        projects = []
+        projects: List[Dict] = []
         conditions = conditions or []
+
         for condition in conditions:
             if condition.column in ("id", "key"):
                 if condition.op == FilterOperator.EQUAL:
-                    projects = [client.get_project(condition.value)]
+                    project = client.get_project(condition.value)
+                    projects.append(project)
                 elif condition.op == FilterOperator.IN:
-                    projects = [client.get_project(project_id) for project_id in condition.value]
+                    for project_id in condition.value:
+                        project = client.get_project(project_id)
+                        projects.append(project)
                 else:
                     raise ValueError(f"Unsupported operator {condition.op} for column {condition.column}.")
                 condition.applied = True
 
         if not projects:
-            projects = client.get_all_projects()
+            all_projects = self._get_all_projects(client)
+            if limit is not None:
+                projects = all_projects[:limit]
+            else:
+                projects = all_projects
 
         return self.to_dataframe(projects)
 
@@ -73,88 +352,145 @@ def get_columns(self) -> List[str]:
             "uuid",
         ]
 
+    # META TABLES
+    @staticmethod
+    def meta_get_tables(table_name: str) -> Dict[str, str]:
+        if table_name == "projects":
+            return {
+                "table_name": "projects",
+                "table_schema": "jira",
+                "table_type": "BASE TABLE",
+                "table_description": "Jira projects available to the configured user.",
+            }
+        return {}
+
+    @staticmethod
+    def meta_get_columns(table_name: str) -> List[Dict]:
+        if table_name == "projects":
+            return [
+                {
+                    "table_name": "projects",
+                    "column_name": "id",
+                    "data_type": "TEXT",
+                    "description": "Project ID",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "projects",
+                    "column_name": "key",
+                    "data_type": "TEXT",
+                    "description": "Project key",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "projects",
+                    "column_name": "name",
+                    "data_type": "TEXT",
+                    "description": "Project name",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "projects",
+                    "column_name": "projectTypeKey",
+                    "data_type": "TEXT",
+                    "description": "Type of the project",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "projects",
+                    "column_name": "simplified",
+                    "data_type": "BOOLEAN",
+                    "description": "Whether the project is simplified",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "projects",
+                    "column_name": "style",
+                    "data_type": "TEXT",
+                    "description": "Style of the project",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "projects",
+                    "column_name": "isPrivate",
+                    "data_type": "BOOLEAN",
+                    "description": "Whether the project is private",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "projects",
+                    "column_name": "entityId",
+                    "data_type": "TEXT",
+                    "description": "Entity ID of the project",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "projects",
+                    "column_name": "uuid",
+                    "data_type": "TEXT",
+                    "description": "UUID of the project",
+                    "is_nullable": False,
+                },
+            ]
+        return []
+
+
+class JiraIssuesTable(JiraIssueFetcherMixin, JiraTableBase):
+    """
+    Issues table: provides normalized issue data across all projects.
+
+    Designed for:
+    - Direct querying of issues.
+    - Feeding Knowledge Bases with summary, description, and comments.
+    """
 
-class JiraIssuesTable(JiraTableBase):
     def list(
         self,
         conditions: Optional[List[FilterCondition]] = None,
         limit: Optional[int] = None,
         sort: Optional[List[SortColumn]] = None,
         targets: Optional[List[str]] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> pd.DataFrame:
         client: Jira = self.handler.connect()
 
-        issues = []
-        conditions = conditions or []
-        for condition in conditions:
-            if condition.column in ("id", "key"):
-                if condition.op == FilterOperator.EQUAL:
-                    issues = [client.get_issue(condition.value)]
-                elif condition.op == FilterOperator.IN:
-                    issues = [client.get_issue(issue_id) for issue_id in condition.value]
-                else:
-                    raise ValueError(f"Unsupported operator {condition.op} for column {condition.column}.")
-                condition.applied = True
-
-            elif condition.column in ("project_id", "project_key", "project_name"):
-                if condition.op == FilterOperator.EQUAL:
-                    issues = client.get_all_project_issues(condition.value, limit=limit)
-                elif condition.op == FilterOperator.IN:
-                    for project_id in condition.value:
-                        issues.extend(client.get_all_project_issues(project_id, limit=limit))
-
-                condition.applied = True
-
-        if not issues:
-            project_ids = [project["id"] for project in client.get_all_projects()]
-            for project_id in project_ids:
-                issues.extend(
-                    self._get_project_issues_with_limit(client, project_id, limit=limit, current_issues=issues)
-                )
+        issues = self._fetch_issues(client, conditions, limit)
 
         if issues:
             return self.normalize(issues)
-        else:
-            return self.to_dataframe(issues)
+        return self.to_dataframe(issues)
 
-    def _get_project_issues_with_limit(
-        self,
-        client: Jira,
-        project_id: str,
-        limit: Optional[int] = None,
-        current_issues: Optional[List] = None,
-    ):
+    def normalize(self, issues: List[dict]) -> pd.DataFrame:
         """
-        Helper to get issues from a project, respecting the limit.
+        Normalize Jira issues into a flat DataFrame schema suitable for SQL and KB usage.
         """
-        if current_issues is None:
-            current_issues = []
-        if limit:
-            remaining = limit - len(current_issues)
-            if remaining <= 0:
-                return []
-            return client.get_all_project_issues(project_id, limit=remaining)
-        else:
-            return client.get_all_project_issues(project_id)
-
-    def normalize(self, issues: dict) -> pd.DataFrame:
         issues_df = pd.json_normalize(issues)
-        # Use errors='ignore' to skip columns that don't exist in the data
         issues_df.rename(
             columns={
                 "fields.project.id": "project_id",
                 "fields.project.key": "project_key",
                 "fields.project.name": "project_name",
+                "fields.issuetype.name": "issue_type",
                 "fields.summary": "summary",
+                "fields.description": "description",
                 "fields.priority.name": "priority",
                 "fields.creator.displayName": "creator",
+                "fields.creator.accountId": "creator_account_id",
+                "fields.reporter.displayName": "reporter",
+                "fields.reporter.accountId": "reporter_account_id",
                 "fields.assignee.displayName": "assignee",
+                "fields.assignee.accountId": "assignee_account_id",
                 "fields.status.name": "status",
+                "fields.status.statusCategory.name": "status_category",
+                "fields.statuscategorychangedate": "status_category_change_date",
+                "fields.duedate": "due_date",
+                "fields.created": "created",
+                "fields.updated": "updated",
             },
             inplace=True,
             errors="ignore",
         )
+
         issues_df = issues_df.reindex(columns=self.get_columns(), fill_value=None)
 
         return issues_df
@@ -166,29 +502,608 @@ def get_columns(self) -> List[str]:
             "project_id",
             "project_key",
             "project_name",
+            "project",
+            "issue_type",
             "summary",
+            "description",
             "priority",
             "creator",
+            "creator_account_id",
+            "reporter",
+            "reporter_account_id",
             "assignee",
+            "assignee_account_id",
             "status",
+            "status_category",
+            "status_category_change_date",
+            "labels",
+            "components",
+            "due_date",
+            "created",
+            "updated",
+        ]
+
+    @staticmethod
+    def _join_simple_list(values: Optional[Iterable]) -> Optional[str]:
+        if isinstance(values, list):
+            filtered = []
+            for val in values:
+                if val not in (None, ""):
+                    filtered.append(str(val))
+            if filtered:
+                return ", ".join(filtered)
+            return None
+        return None
+
+    @staticmethod
+    def _join_component_names(values: Optional[Iterable]) -> Optional[str]:
+        if isinstance(values, list):
+            names: List[str] = []
+            for component in values:
+                if isinstance(component, dict):
+                    name = component.get("name")
+                    if name:
+                        names.append(name)
+            if names:
+                return ", ".join(names)
+            return None
+        return None
+
+    @staticmethod
+    def _join_comment_bodies(values: Optional[Iterable]) -> Optional[str]:
+        if isinstance(values, list):
+            comments: List[str] = []
+            for comment in values:
+                if isinstance(comment, dict):
+                    body = comment.get("body")
+                    if body:
+                        comments.append(body)
+            if comments:
+                return "\n\n".join(comments)
+            return None
+        return None
+
+    # META TABLES
+    @staticmethod
+    def meta_get_tables(table_name: str) -> Dict[str, str]:
+        if table_name == "issues":
+            return {
+                "table_name": "issues",
+                "table_schema": "jira",
+                "table_type": "BASE TABLE",
+                "table_description": "Jira issues across all projects accessible to the configured user.",
+            }
+        return {}
+
+    @staticmethod
+    def meta_get_columns(table_name: str) -> List[Dict]:
+        if table_name == "issues":
+            return [
+                {
+                    "table_name": "issues",
+                    "column_name": "id",
+                    "data_type": "TEXT",
+                    "description": "Issue ID",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "key",
+                    "data_type": "TEXT",
+                    "description": "Issue key",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "project_id",
+                    "data_type": "TEXT",
+                    "description": "ID of the project the issue belongs to",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "project_key",
+                    "data_type": "TEXT",
+                    "description": "Key of the project the issue belongs to",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "project_name",
+                    "data_type": "TEXT",
+                    "description": "Name of the project the issue belongs to",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "project",
+                    "data_type": "TEXT",
+                    "description": "Project information as a JSON string",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "issue_type",
+                    "data_type": "TEXT",
+                    "description": "Type of the issue",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "summary",
+                    "data_type": "TEXT",
+                    "description": "Summary of the issue",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "description",
+                    "data_type": "TEXT",
+                    "description": "Description of the issue",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "priority",
+                    "data_type": "TEXT",
+                    "description": "Priority of the issue",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "creator",
+                    "data_type": "TEXT",
+                    "description": "Display name of the issue creator",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "creator_account_id",
+                    "data_type": "TEXT",
+                    "description": "Account ID of the issue creator",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "reporter",
+                    "data_type": "TEXT",
+                    "description": "Display name of the issue reporter",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "reporter_account_id",
+                    "data_type": "TEXT",
+                    "description": "Account ID of the issue reporter",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "assignee",
+                    "data_type": "TEXT",
+                    "description": "Display name of the issue assignee",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "assignee_account_id",
+                    "data_type": "TEXT",
+                    "description": "Account ID of the issue assignee",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "status",
+                    "data_type": "TEXT",
+                    "description": "Current status of the issue",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "status_category",
+                    "data_type": "TEXT",
+                    "description": "Category of the current status",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "status_category_change_date",
+                    "data_type": "TIMESTAMP",
+                    "description": "Date when the status category last changed",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "labels",
+                    "data_type": "TEXT",
+                    "description": "Comma-separated labels associated with the issue",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "components",
+                    "data_type": "TEXT",
+                    "description": "Comma-separated component names associated with the issue",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "due_date",
+                    "data_type": "DATE",
+                    "description": "Due date of the issue",
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "created",
+                    "data_type": "TIMESTAMP",
+                    "description": "Creation date of the issue",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "issues",
+                    "column_name": "updated",
+                    "data_type": "TIMESTAMP",
+                    "description": "Last updated date of the issue",
+                    "is_nullable": False,
+                },
+            ]
+        return []
+
+
+class JiraAttachmentsTable(JiraIssueFetcherMixin, JiraTableBase):
+    """
+    Attachments table: derived from issue attachments.
+    """
+
+    def list(
+        self,
+        conditions: Optional[List[FilterCondition]] = None,
+        limit: Optional[int] = None,
+        sort: Optional[List[SortColumn]] = None,
+        targets: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> pd.DataFrame:
+        client: Jira = self.handler.connect()
+        issues = self._fetch_issues(client, conditions, None)
+        attachment_rows = self._build_attachment_rows(client, issues, limit)
+        return self.to_dataframe(attachment_rows)
+
+    def _build_attachment_rows(
+        self,
+        client: Jira,
+        issues: List[Dict],
+        limit: Optional[int],
+    ) -> List[Dict]:
+        attachments: List[Dict] = []
+
+        for issue in issues:
+            if not isinstance(issue, dict):
+                continue
+
+            issue_attachments = self._get_issue_field(client, issue, "attachment") or []
+            if not isinstance(issue_attachments, list):
+                continue
+
+            for attachment in issue_attachments:
+                if not isinstance(attachment, dict):
+                    continue
+
+                row = {
+                    "issue_id": issue.get("id"),
+                    "issue_key": issue.get("key"),
+                    "attachment_id": attachment.get("id"),
+                    "filename": attachment.get("filename"),
+                    "mime_type": attachment.get("mimeType"),
+                    "size": attachment.get("size"),
+                    "content_url": attachment.get("content"),
+                    "thumbnail_url": attachment.get("thumbnail"),
+                    "created": attachment.get("created"),
+                    "author": (attachment.get("author") or {}).get("displayName"),
+                    "author_account_id": (attachment.get("author") or {}).get("accountId"),
+                }
+                attachments.append(row)
+
+                if limit is not None and len(attachments) >= limit:
+                    return attachments
+
+        return attachments
+
+    def get_columns(self) -> List[str]:
+        return [
+            "issue_id",
+            "issue_key",
+            "attachment_id",
+            "filename",
+            "mime_type",
+            "size",
+            "content_url",
+            "thumbnail_url",
+            "created",
+            "author",
+            "author_account_id",
         ]
 
+    # META TABLES
+    @staticmethod
+    def meta_get_tables(table_name: str) -> Dict[str, str]:
+        if table_name == "attachments":
+            return {
+                "table_name": "attachments",
+                "table_schema": "jira",
+                "table_type": "BASE TABLE",
+                "table_description": "Jira issue attachments across all projects accessible to the configured user.",
+            }
+        return {}
+
+    @staticmethod
+    def meta_get_columns(table_name: str) -> List[Dict]:
+        if table_name == "attachments":
+            return [
+                {
+                    "table_name": "attachments",
+                    "column_name": "issue_id",
+                    "data_type": "TEXT",
+                    "description": "ID of the issue the attachment belongs to",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "attachments",
+                    "column_name": "issue_key",
+                    "data_type": "TEXT",
+                    "description": "Key of the issue the attachment belongs to",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "attachments",
+                    "column_name": "attachment_id",
+                    "data_type": "TEXT",
+                    "description": "ID of the attachment",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "attachments",
+                    "column_name": "filename",
+                    "data_type": "TEXT",
+                    "description": "Filename of the attachment",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "attachments",
+                    "column_name": "mime_type",
+                    "data_type": "TEXT",
+                    "description": "MIME type of the attachment",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "attachments",
+                    "column_name": "size",
+                    "data_type": "INTEGER",
+                    "description": "Size of the attachment in bytes",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "attachments",
+                    "column_name": "content_url",
+                    "data_type": "TEXT",
+                    "description": "URL to access the content of the attachment",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "attachments",
+                    "column_name": "thumbnail_url",
+                    "data_type": "TEXT",
+                    "description": "URL to access the thumbnail of the attachment",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "attachments",
+                    "column_name": "created",
+                    "data_type": "TIMESTAMP",
+                    "description": "Creation date of the attachment",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "attachments",
+                    "column_name": "author",
+                    "data_type": "TEXT",
+                    "description": "Display name of the attachment author",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "attachments",
+                    "column_name": "author_account_id",
+                    "data_type": "TEXT",
+                    "description": "Account ID of the attachment author",
+                    "is_nullable": False,
+                },
+            ]
+        return []
+
+
+class JiraCommentsTable(JiraIssueFetcherMixin, JiraTableBase):
+    """
+    Comments table: derived from issue comments.
+    """
+
+    def list(
+        self,
+        conditions: Optional[List[FilterCondition]] = None,
+        limit: Optional[int] = None,
+        sort: Optional[List[SortColumn]] = None,
+        targets: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> pd.DataFrame:
+        client: Jira = self.handler.connect()
+        issues = self._fetch_issues(client, conditions, None)
+        comment_rows = self._build_comment_rows(client, issues, limit)
+        return self.to_dataframe(comment_rows)
+
+    def _build_comment_rows(
+        self,
+        client: Jira,
+        issues: List[Dict],
+        limit: Optional[int],
+    ) -> List[Dict]:
+        comments_rows: List[Dict] = []
+
+        for issue in issues:
+            if not isinstance(issue, dict):
+                continue
+
+            comments_container = self._get_issue_field(client, issue, "comment") or {}
+            if isinstance(comments_container, dict):
+                issue_comments = comments_container.get("comments", [])
+            else:
+                issue_comments = []
+
+            for comment in issue_comments:
+                if not isinstance(comment, dict):
+                    continue
+
+                row = {
+                    "issue_id": issue.get("id"),
+                    "issue_key": issue.get("key"),
+                    "comment_id": comment.get("id"),
+                    "body": comment.get("body"),
+                    "created": comment.get("created"),
+                    "updated": comment.get("updated"),
+                    "author": (comment.get("author") or {}).get("displayName"),
+                    "author_account_id": (comment.get("author") or {}).get("accountId"),
+                    "visibility_type": (comment.get("visibility") or {}).get("type"),
+                    "visibility_value": (comment.get("visibility") or {}).get("value"),
+                }
+                comments_rows.append(row)
+
+                if limit is not None and len(comments_rows) >= limit:
+                    return comments_rows
+
+        return comments_rows
+
+    def get_columns(self) -> List[str]:
+        return [
+            "issue_id",
+            "issue_key",
+            "comment_id",
+            "body",
+            "created",
+            "updated",
+            "author",
+            "author_account_id",
+            "visibility_type",
+            "visibility_value",
+        ]
+
+    # META TABLES
+    @staticmethod
+    def meta_get_tables(table_name: str) -> Dict[str, str]:
+        if table_name == "comments":
+            return {
+                "table_name": "comments",
+                "table_schema": "jira",
+                "table_type": "BASE TABLE",
+                "table_description": "Jira issue comments across all projects accessible to the configured user.",
+            }
+        return {}
+
+    @staticmethod
+    def meta_get_columns(table_name: str) -> List[Dict]:
+        if table_name == "comments":
+            return [
+                {
+                    "table_name": "comments",
+                    "column_name": "issue_id",
+                    "data_type": "TEXT",
+                    "description": "ID of the issue the comment belongs to",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "comments",
+                    "column_name": "issue_key",
+                    "data_type": "TEXT",
+                    "description": "Key of the issue the comment belongs to",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "comments",
+                    "column_name": "comment_id",
+                    "data_type": "TEXT",
+                    "description": "ID of the comment",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "comments",
+                    "column_name": "body",
+                    "data_type": "TEXT",
+                    "description": "Body of the comment",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "comments",
+                    "column_name": "created",
+                    "data_type": "TIMESTAMP",
+                    "description": "Creation date of the comment",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "comments",
+                    "column_name": "updated",
+                    "data_type": "TIMESTAMP",
+                    "description": "Last updated date of the comment",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "comments",
+                    "column_name": "author",
+                    "data_type": "TEXT",
+                    "description": "Display name of the comment author",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "comments",
+                    "column_name": "author_account_id",
+                    "data_type": "TEXT",
+                    "description": "Account ID of the comment author",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "comments",
+                    "column_name": "visibility_type",
+                    "data_type": "TEXT",
+                    "description": "Type of visibility for the comment",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "comments",
+                    "column_name": "visibility_value",
+                    "data_type": "TEXT",
+                    "description": "Value of visibility for the comment",
+                    "is_nullable": False,
+                },
+            ]
+        return []
+
 
 class JiraGroupsTable(JiraTableBase):
+    """
+    Groups table: user groups available in Jira.
+    """
+
     def list(
         self,
         conditions: Optional[List[FilterCondition]] = None,
         limit: Optional[int] = None,
         sort: Optional[List[SortColumn]] = None,
         targets: Optional[List[str]] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> pd.DataFrame:
         client: Jira = self.handler.connect()
 
-        if limit:
-            groups = client.get_groups(limit=limit)["groups"]
+        if limit is not None:
+            group_response = client.get_groups(limit=limit)
         else:
-            groups = client.get_groups()["groups"]
+            group_response = client.get_groups()
+
+        groups = group_response.get("groups", [])
 
         return self.to_dataframe(groups)
 
@@ -199,45 +1114,246 @@ def get_columns(self) -> List[str]:
             "html",
         ]
 
+    # META TABLES
+    @staticmethod
+    def meta_get_tables(table_name: str) -> Dict[str, str]:
+        if table_name == "groups":
+            return {
+                "table_name": "groups",
+                "table_schema": "jira",
+                "table_type": "BASE TABLE",
+                "table_description": "Jira user groups available to the configured user.",
+            }
+        return {}
+
+    @staticmethod
+    def meta_get_columns(table_name: str) -> List[Dict]:
+        if table_name == "groups":
+            return [
+                {
+                    "table_name": "groups",
+                    "column_name": "groupId",
+                    "data_type": "TEXT",
+                    "description": "Group ID",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "groups",
+                    "column_name": "name",
+                    "data_type": "TEXT",
+                    "description": "Group name",
+                    "is_nullable": False,
+                },
+                {
+                    "table_name": "groups",
+                    "column_name": "html",
+                    "data_type": "TEXT",
+                    "description": "HTML representation of the group",
+                    "is_nullable": False,
+                },
+            ]
+        return []
+
 
 class JiraUsersTable(JiraTableBase):
+    """
+    Users table: users accessible to the current Jira context.
+    """
+
     def list(
         self,
         conditions: Optional[List[FilterCondition]] = None,
         limit: Optional[int] = None,
         sort: Optional[List[SortColumn]] = None,
         targets: Optional[List[str]] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> pd.DataFrame:
         client: Jira = self.handler.connect()
 
-        users = []
+        is_cloud = getattr(client, "cloud", None)
+        if is_cloud is False:
+            self._column_mode = "server"
+            users = self.get_server_users(client, conditions, limit)
+        else:
+            self._column_mode = "cloud"
+            users = self.get_cloud_users(client, conditions, limit)
+
+        return self.to_dataframe(users)
+
+    def get_cloud_users(
+        self,
+        client: Jira,
+        conditions: Optional[List[FilterCondition]],
+        limit: Optional[int],
+    ) -> List[Dict]:
+        users: List[Dict] = []
         conditions = conditions or []
+
         for condition in conditions:
             if condition.column == "accountId":
                 if condition.op == FilterOperator.EQUAL:
-                    users = [client.user(account_id=condition.value)]
+                    user = client.user(account_id=condition.value)
+                    if isinstance(user, dict):
+                        users.append(user)
+                    else:
+                        logger.debug(
+                            "Skipping non-dict user result for account_id %s: %s",
+                            condition.value,
+                            type(user).__name__,
+                        )
                 elif condition.op == FilterOperator.IN:
-                    users = [client.user(account_id=accountId) for accountId in condition.value]
+                    for account_id in condition.value:
+                        user = client.user(account_id=account_id)
+                        if isinstance(user, dict):
+                            users.append(user)
+                        else:
+                            logger.debug(
+                                "Skipping non-dict user result for account_id %s: %s",
+                                account_id,
+                                type(user).__name__,
+                            )
                 else:
                     raise ValueError(f"Unsupported operator {condition.op} for column {condition.column}.")
                 condition.applied = True
 
         if not users:
-            if limit:
-                users = client.users_get_all(limit=limit)
-            else:
-                users = client.users_get_all()
+            users = self._fetch_all_users(client, limit)
 
-        return self.to_dataframe(users)
+        return users
+
+    def get_server_users(
+        self,
+        client: Jira,
+        conditions: Optional[List[FilterCondition]],
+        limit: Optional[int],
+    ) -> List[Dict]:
+        users: List[Dict] = []
+        conditions = conditions or []
+
+        for condition in conditions:
+            if condition.column in ("username", "name", "accountId"):
+                if condition.op == FilterOperator.IN:
+                    values = condition.value if isinstance(condition.value, (list, tuple, set)) else [condition.value]
+                elif condition.op == FilterOperator.EQUAL:
+                    values = [condition.value]
+                else:
+                    raise ValueError(f"Unsupported operator {condition.op} for column {condition.column}.")
+                for value in values:
+                    try:
+                        user = client.user(username=value)
+                    except HTTPError as user_error:
+                        logger.debug("Failed to fetch server user '%s': %s", value, user_error)
+                        continue
+                    if isinstance(user, dict):
+                        users.append(user)
+                condition.applied = True
+
+        if not users:
+            try:
+                user = client.user(username=".")
+                if isinstance(user, dict):
+                    users.append(user)
+            except HTTPError as user_error:
+                logger.debug("Failed to fetch default server user '%s': %s", ".", user_error)
+        if not users:
+            users = self._fetch_all_users(client, limit)
+
+        return users
+
+    def _fetch_all_users(self, client: Jira, limit: Optional[int]) -> List[Dict]:
+        """
+        Fetch all accessible users with pagination and a fallback for Jira Cloud.
+        """
+        users: List[Dict] = []
+        start = 0
+        page_size = limit or 50
+        if page_size <= 0:
+            page_size = 50
+
+        while True:
+            try:
+                resp = client.users_get_all(start=start, limit=page_size)
+                page_users = self._normalize_users_response(resp)
+                if not isinstance(resp, (list, dict)) and not page_users:
+                    raise HTTPError(f"Unexpected users response: {resp}")
+            except HTTPError as exc:
+                logger.warning(
+                    "users_get_all failed (start=%s, limit=%s): %s; falling back to user search",
+                    start,
+                    page_size,
+                    exc,
+                )
+                resp, page_users = self._fallback_user_search(client, start, page_size, exc)
+
+            users.extend(page_users)
+
+            if limit is not None and len(users) >= limit:
+                return users[:limit]
+
+            if len(page_users) < page_size:
+                break
+
+            start += len(page_users)
+
+        return users
+
+    def _fallback_user_search(
+        self, client: Jira, start: int, page_size: int, original_exc: HTTPError
+    ) -> Tuple[Any, List[Dict]]:
+        """
+        Jira user search using both cloud and server parameter styles.
+        """
+        is_cloud = getattr(client, "cloud", None)
+        search_variants: List[Dict[str, Any]] = []
+
+        if is_cloud is False:
+            search_variants.append({"username": ".", "start": start, "limit": page_size})
+            search_variants.append({"query": ".", "start": start, "limit": page_size})
+        else:
+            search_variants.append({"query": ".", "start": start, "limit": page_size})
+            search_variants.append({"username": ".", "start": start, "limit": page_size})
+
+        for params in search_variants:
+            try:
+                resp = client.user_find_by_user_string(**params)
+            except HTTPError as search_exc:
+                logger.error(
+                    "user search failed (params=%s): %s",
+                    params,
+                    search_exc,
+                )
+                continue
+
+            page_users = self._normalize_users_response(resp)
+            if isinstance(resp, (list, dict)) or page_users:
+                return resp, page_users
+
+            logger.debug(
+                "Unexpected users search response (params=%s): %s",
+                params,
+                resp,
+            )
+
+        raise HTTPError(f"Unexpected users response: {original_exc}")
+
+    def _normalize_users_response(self, resp: Any) -> List[Dict]:
+        """
+        Normalize user API responses to a list of dicts.
+        """
+        if isinstance(resp, list):
+            return resp
+        if isinstance(resp, dict):
+            users = resp.get("users") or resp.get("values") or []
+            if users:
+                return users
+            if resp:
+                return [resp]
+            return []
+        logger.debug("Unexpected users response type: %s", type(resp).__name__)
+        return []
 
     def get_columns(self) -> List[str]:
-        return [
-            "accountId",
-            "accountType",
-            "emailAddress",
-            "displayName",
-            "active",
-            "timeZone",
-            "locale",
-        ]
+        column_mode = getattr(self, "_column_mode", "cloud")
+        if column_mode == "server":
+            return SERVER_COLUMNS
+        return CLOUD_COLUMNS
diff --git a/mindsdb/integrations/handlers/lindorm_handler/requirements.txt b/mindsdb/integrations/handlers/lindorm_handler/requirements.txt
index 526500be75b..0c562cda190 100644
--- a/mindsdb/integrations/handlers/lindorm_handler/requirements.txt
+++ b/mindsdb/integrations/handlers/lindorm_handler/requirements.txt
@@ -1,3 +1,3 @@
 pyphoenix
 phoenixdb
-protobuf==4.25.8
\ No newline at end of file
+protobuf==5.29.6
\ No newline at end of file
diff --git a/mindsdb/integrations/handlers/milvus_handler/requirements.txt b/mindsdb/integrations/handlers/milvus_handler/requirements.txt
index 4872c767649..780dc2add48 100644
--- a/mindsdb/integrations/handlers/milvus_handler/requirements.txt
+++ b/mindsdb/integrations/handlers/milvus_handler/requirements.txt
@@ -1 +1,2 @@
 pymilvus==2.3
+protobuf>=6.33.5 # not directly required, pinned by Snyk to avoid a vulnerability
diff --git a/mindsdb/integrations/handlers/mlflow_handler/requirements.txt b/mindsdb/integrations/handlers/mlflow_handler/requirements.txt
index 40d1d2b4967..3ccfa559cbe 100644
--- a/mindsdb/integrations/handlers/mlflow_handler/requirements.txt
+++ b/mindsdb/integrations/handlers/mlflow_handler/requirements.txt
@@ -1,2 +1,3 @@
 mlflow
+protobuf>=6.33.5 # not directly required, pinned by Snyk to avoid a vulnerability
 sqlparse>=0.5.4 # not directly required, pinned by Snyk to avoid a vulnerability
diff --git a/mindsdb/integrations/handlers/mssql_handler/mssql_handler.py b/mindsdb/integrations/handlers/mssql_handler/mssql_handler.py
index bfff010e02b..7b6e42fff34 100644
--- a/mindsdb/integrations/handlers/mssql_handler/mssql_handler.py
+++ b/mindsdb/integrations/handlers/mssql_handler/mssql_handler.py
@@ -327,7 +327,7 @@ def check_connection(self) -> StatusResponse:
                 # Execute a simple query to test the connection
                 cur.execute("select 1;")
             response.success = True
-        except OperationalError as e:
+        except Exception as e:
             logger.error(f"Error connecting to Microsoft SQL Server {self.database}, {e}!")
             response.error_message = str(e)
 
diff --git a/mindsdb/integrations/handlers/mysql_handler/mysql_handler.py b/mindsdb/integrations/handlers/mysql_handler/mysql_handler.py
index 2b6c67c4eea..86882d03563 100644
--- a/mindsdb/integrations/handlers/mysql_handler/mysql_handler.py
+++ b/mindsdb/integrations/handlers/mysql_handler/mysql_handler.py
@@ -1,4 +1,4 @@
-from typing import Optional, List, Dict, Any
+from typing import Optional, List, Dict, Any, Generator
 
 import pandas as pd
 import mysql.connector
@@ -12,11 +12,16 @@
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
-    RESPONSE_TYPE,
+    TableResponse,
+    OkResponse,
+    ErrorResponse,
+    DataHandlerResponse,
 )
 from mindsdb.integrations.handlers.mysql_handler.settings import ConnectionConfig
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import C_TYPES, DATA_C_TYPE_MAP
+from mindsdb.utilities.types.column import Column
+from mindsdb.utilities.config import config as mindsdb_config
 
 logger = log.getLogger(__name__)
 
@@ -37,57 +42,47 @@ def _map_type(mysql_type_text: str) -> MYSQL_DATA_TYPE:
         return MYSQL_DATA_TYPE.TEXT
 
 
-def _make_table_response(result: List[Dict[str, Any]], cursor: mysql.connector.cursor.MySQLCursor) -> Response:
-    """Build response from result and cursor.
+def _get_columns(cursor: mysql.connector.cursor.MySQLCursor) -> list[Column]:
+    """Get columns from cursor description.
 
     Args:
-        result (list[dict]): result of the query.
         cursor (mysql.connector.cursor.MySQLCursor): cursor object.
 
     Returns:
-        Response: response object.
+        list[Column]: List of Column objects with type and dtype info.
     """
     description = cursor.description
     reverse_c_type_map = {v.code: k for k, v in DATA_C_TYPE_MAP.items() if v.code != C_TYPES.MYSQL_TYPE_BLOB}
-    mysql_types: list[MYSQL_DATA_TYPE] = []
+    columns = []
     for col in description:
+        column_name = col[0]
         type_int = col[1]
-        if isinstance(type_int, int) is False:
-            mysql_types.append(MYSQL_DATA_TYPE.TEXT)
-            continue
 
-        if type_int == C_TYPES.MYSQL_TYPE_TINY:
+        if isinstance(type_int, int) is False:
+            mysql_type = MYSQL_DATA_TYPE.TEXT
+        elif type_int == C_TYPES.MYSQL_TYPE_TINY:
             # There are 3 types that returns as TINYINT: TINYINT, BOOL, BOOLEAN.
-            mysql_types.append(MYSQL_DATA_TYPE.TINYINT)
-            continue
-
-        if type_int in reverse_c_type_map:
-            mysql_types.append(reverse_c_type_map[type_int])
-            continue
-
-        if type_int == C_TYPES.MYSQL_TYPE_BLOB:
+            mysql_type = MYSQL_DATA_TYPE.TINYINT
+        elif type_int in reverse_c_type_map:
+            mysql_type = reverse_c_type_map[type_int]
+        elif type_int == C_TYPES.MYSQL_TYPE_BLOB:
             # region determine text/blob type by flags
             # Unfortunately, there is no way to determine particular type of text/blob column by flags.
             # Subtype have to be determined by 8-s element of description tuple, but mysql.conector
             # return the same value for all text types (TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT), and for
             # all blob types (TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB).
-            if col[7] == 16:  # and col[8] == 45
-                mysql_types.append(MYSQL_DATA_TYPE.TEXT)
-            elif col[7] == 144:  # and col[8] == 63
-                mysql_types.append(MYSQL_DATA_TYPE.BLOB)
+            if col[7] == 16:
+                mysql_type = MYSQL_DATA_TYPE.TEXT
+            elif col[7] == 144:
+                mysql_type = MYSQL_DATA_TYPE.BLOB
             else:
                 logger.debug(f"MySQL handler: unknown type code {col[7]}, use TEXT as fallback.")
-                mysql_types.append(MYSQL_DATA_TYPE.TEXT)
+                mysql_type = MYSQL_DATA_TYPE.TEXT
             # endregion
         else:
-            logger.warning(f"MySQL handler: unknown type id={type_int} in column {col[0]}, use TEXT as fallback.")
-            mysql_types.append(MYSQL_DATA_TYPE.TEXT)
+            logger.warning(f"MySQL handler: unknown type id={type_int} in column {column_name}, use TEXT as fallback.")
+            mysql_type = MYSQL_DATA_TYPE.TEXT
 
-    # region cast int and bool to nullable types
-    serieses = []
-    for i, mysql_type in enumerate(mysql_types):
-        expected_dtype = None
-        column_name = description[i][0]
         if mysql_type in (
             MYSQL_DATA_TYPE.SMALLINT,
             MYSQL_DATA_TYPE.INT,
@@ -98,12 +93,27 @@ def _make_table_response(result: List[Dict[str, Any]], cursor: mysql.connector.c
             expected_dtype = "Int64"
         elif mysql_type in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
             expected_dtype = "boolean"
-        serieses.append(pd.Series([row[column_name] for row in result], dtype=expected_dtype, name=description[i][0]))
-    df = pd.concat(serieses, axis=1, copy=False)
-    # endregion
+        else:
+            expected_dtype = None
+
+        columns.append(Column(name=column_name, type=mysql_type, dtype=expected_dtype))
+    return columns
+
+
+def _make_df(result: list[tuple[Any]], columns: list[Column]) -> pd.DataFrame:
+    """Make pandas DataFrame from result and columns.
+
+    Args:
+        result (list[tuple[Any]]): result of the query (list of tuples).
+        columns (list[Column]): list of columns.
 
-    response = Response(RESPONSE_TYPE.TABLE, df, affected_rows=cursor.rowcount, mysql_types=mysql_types)
-    return response
+    Returns:
+        pd.DataFrame: pandas DataFrame.
+    """
+    serieses = []
+    for i, column in enumerate(columns):
+        serieses.append(pd.Series([row[i] for row in result], dtype=column.dtype, name=column.name))
+    return pd.concat(serieses, axis=1, copy=False)
 
 
 class MySQLHandler(MetaDatabaseHandler):
@@ -112,6 +122,7 @@ class MySQLHandler(MetaDatabaseHandler):
     """
 
     name = "mysql"
+    stream_response = True
 
     def __init__(self, name: str, **kwargs: Any) -> None:
         super().__init__(name)
@@ -229,41 +240,100 @@ def check_connection(self) -> StatusResponse:
 
         return result
 
-    def native_query(self, query: str) -> Response:
-        """
-        Executes a SQL query on the MySQL database and returns the result.
+    def native_query(self, query: str, stream: bool = True, **kwargs) -> DataHandlerResponse:
+        """Executes a SQL query on the MySQL database and returns the result.
 
         Args:
             query (str): The SQL query to be executed.
+            stream (bool): Whether to stream the results of the query.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            Response: A response object containing the result of the query or an error message.
+            DataHandlerResponse: A response object containing the result of the query or an error message.
         """
-        need_to_close = not self.is_connected
-        connection = None
-        try:
-            connection = self.connect()
-            with connection.cursor(dictionary=True, buffered=True) as cur:
-                cur.execute(query)
-                if cur.with_rows:
-                    result = cur.fetchall()
-                    response = _make_table_response(result, cur)
-                else:
-                    response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
-        except mysql.connector.Error as e:
-            logger.error(
-                f"Error running query: {query} on {self.connection_data.get('database', 'unknown')}! Error: {e}"
-            )
-            response = Response(RESPONSE_TYPE.ERROR, error_code=e.errno or 1, error_message=str(e))
-            if connection is not None and connection.is_connected():
-                connection.rollback()
+        if stream is False:
+            response = self._execute_fetchall(query)
+        else:
+            generator = self._execute_fetchmany(query)
+            try:
+                response: TableResponse = next(generator)
+                response.data_generator = generator
+            except StopIteration as e:
+                response = e.value
+                if isinstance(response, DataHandlerResponse) is False:
+                    raise
+        return response
 
-        if need_to_close:
-            self.disconnect()
+    def _execute_fetchall(self, query: str) -> DataHandlerResponse:
+        """Executes a SQL query on the MySQL database and returns the full result at once.
+
+        Args:
+            query (str): The SQL query to be executed.
 
+        Returns:
+            DataHandlerResponse: A response object containing the result of the query or an error message.
+        """
+        connection = self.connect()
+        with connection.cursor(buffered=True) as cursor:
+            try:
+                cursor.execute(query)
+                if cursor.with_rows:
+                    result = cursor.fetchall()
+                    columns = _get_columns(cursor)
+                    df = _make_df(result, columns)
+                    response = TableResponse(data=df, affected_rows=cursor.rowcount, columns=columns)
+                else:
+                    response = OkResponse(affected_rows=cursor.rowcount)
+            except Exception as e:
+                response = self._handle_query_exception(e, query, connection)
         return response
 
-    def query(self, query: ASTNode) -> Response:
+    def _execute_fetchmany(
+        self, query: str
+    ) -> Generator[TableResponse | pd.DataFrame, None, OkResponse | ErrorResponse]:
+        """Execute a SQL query on the MySQL database and return a generator of data frames.
+
+        Args:
+            query (str): The SQL query to be executed.
+
+        Returns:
+            Generator[TableResponse | pd.DataFrame, None, OkResponse | ErrorResponse]: Generator of data frames.
+        """
+        connection = self.connect()
+        with connection.cursor(buffered=False) as cursor:
+            try:
+                cursor.execute(query)
+                if not cursor.with_rows:
+                    return OkResponse(affected_rows=cursor.rowcount)
+
+                columns = _get_columns(cursor)
+                yield TableResponse(affected_rows=cursor.rowcount, columns=columns)
+
+                fetch_size = mindsdb_config["data_stream"]["fetch_size"]
+                while result := cursor.fetchmany(size=fetch_size):
+                    yield _make_df(result, columns)
+            except Exception as e:
+                return self._handle_query_exception(e, query, connection)
+
+    def _handle_query_exception(self, e: Exception, query: str, connection) -> ErrorResponse:
+        """Handle query execution errors with appropriate logging and rollback.
+
+        Args:
+            e: The exception that was raised
+            query: The SQL query that failed
+            connection: The database connection to rollback
+
+        Returns:
+            ErrorResponse with appropriate error details
+        """
+        logger.error(f"Error running query: {query} on {self.connection_data.get('database', 'unknown')}! Error: {e}")
+        if connection is not None and connection.is_connected():
+            connection.rollback()
+        if isinstance(e, mysql.connector.Error):
+            return ErrorResponse(error_code=e.errno or 1, error_message=str(e))
+        return ErrorResponse(error_code=0, error_message=str(e))
+
+    def query(self, query: ASTNode) -> DataHandlerResponse:
         """
         Retrieve the data from the SQL statement.
         """
@@ -312,7 +382,8 @@ def get_columns(self, table_name: str) -> Response:
             from
                 information_schema.columns
             where
-                table_name = '{table_name}';
+                table_name = '{table_name}'
+                and table_schema = DATABASE();
         """
         result = self.native_query(q)
         result.to_columns_table_response(map_type_fn=_map_type)
diff --git a/mindsdb/integrations/handlers/netsuite_handler/__init__.py b/mindsdb/integrations/handlers/netsuite_handler/__init__.py
index 673d6ed81ed..c2272c38724 100644
--- a/mindsdb/integrations/handlers/netsuite_handler/__init__.py
+++ b/mindsdb/integrations/handlers/netsuite_handler/__init__.py
@@ -14,7 +14,7 @@
 title = "Oracle NetSuite"
 name = "netsuite"
 type = HANDLER_TYPE.DATA
-icon_path = "netsuite.svg"
+icon_path = "icon.svg"
 
 __all__ = [
     "Handler",
diff --git a/mindsdb/integrations/handlers/netsuite_handler/netsuite.svg b/mindsdb/integrations/handlers/netsuite_handler/icon.svg
similarity index 100%
rename from mindsdb/integrations/handlers/netsuite_handler/netsuite.svg
rename to mindsdb/integrations/handlers/netsuite_handler/icon.svg
diff --git a/mindsdb/integrations/handlers/ollama_handler/__about__.py b/mindsdb/integrations/handlers/ollama_handler/__about__.py
index d379f39e148..37799994782 100644
--- a/mindsdb/integrations/handlers/ollama_handler/__about__.py
+++ b/mindsdb/integrations/handlers/ollama_handler/__about__.py
@@ -1,9 +1,9 @@
-__title__ = 'MindsDB Ollama handler'
-__package_name__ = 'mindsdb_ollama_handler'
-__version__ = '0.0.1'
+__title__ = "MindsDB Ollama handler"
+__package_name__ = "mindsdb_ollama_handler"
+__version__ = "0.0.1"
 __description__ = "MindsDB handler for Ollama"
-__author__ = 'MindsDB Inc'
-__github__ = 'https://github.com/mindsdb/mindsdb'
-__pypi__ = 'https://pypi.org/project/mindsdb/'
-__license__ = 'MIT'
-__copyright__ = 'Copyright 2023- mindsdb'
+__author__ = "MindsDB Inc"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2023- mindsdb"
diff --git a/mindsdb/integrations/handlers/ollama_handler/__init__.py b/mindsdb/integrations/handlers/ollama_handler/__init__.py
index 806f750edb9..eea6a1903d6 100644
--- a/mindsdb/integrations/handlers/ollama_handler/__init__.py
+++ b/mindsdb/integrations/handlers/ollama_handler/__init__.py
@@ -1,19 +1,19 @@
 from mindsdb.integrations.libs.const import HANDLER_TYPE
 
 from .__about__ import __version__ as version, __description__ as description
+
 try:
     from .ollama_handler import OllamaHandler as Handler
+
     import_error = None
 except Exception as e:
     Handler = None
     import_error = e
 
-title = 'Ollama'
-name = 'ollama'
+title = "Ollama"
+name = "ollama"
 type = HANDLER_TYPE.ML
-icon_path = 'icon.png'
+icon_path = "icon.png"
 permanent = False
 
-__all__ = [
-    'Handler', 'version', 'name', 'type', 'title', 'description', 'import_error', 'icon_path'
-]
+__all__ = ["Handler", "version", "name", "type", "title", "description", "import_error", "icon_path"]
diff --git a/mindsdb/integrations/handlers/ollama_handler/ollama_handler.py b/mindsdb/integrations/handlers/ollama_handler/ollama_handler.py
index 5b03b2a1f68..639345933fa 100644
--- a/mindsdb/integrations/handlers/ollama_handler/ollama_handler.py
+++ b/mindsdb/integrations/handlers/ollama_handler/ollama_handler.py
@@ -14,38 +14,40 @@ class OllamaHandler(BaseMLEngine):
 
     @staticmethod
     def create_validation(target, args=None, **kwargs):
-        if 'using' not in args:
+        if "using" not in args:
             raise Exception("Ollama engine requires a USING clause! Refer to its documentation for more details.")
         else:
-            args = args['using']
+            args = args["using"]
 
-        if 'model_name' not in args:
-            raise Exception('`model_name` must be provided in the USING clause.')
+        if "model_name" not in args:
+            raise Exception("`model_name` must be provided in the USING clause.")
 
         # check ollama service health
-        connection = args.get('ollama_serve_url', OllamaHandler.DEFAULT_SERVE_URL)
-        status = requests.get(connection + '/api/tags').status_code
+        connection = args.get("ollama_serve_url", OllamaHandler.DEFAULT_SERVE_URL)
+        status = requests.get(connection + "/api/tags").status_code
         if status != 200:
-            raise Exception(f"Ollama service is not working (status `{status}`). Please double check it is running and try again.")  # noqa
+            raise Exception(
+                f"Ollama service is not working (status `{status}`). Please double check it is running and try again."
+            )  # noqa
 
     def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
-        """ Pull LLM artifacts with Ollama API. """
+        """Pull LLM artifacts with Ollama API."""
         # arg setter
-        args = args['using']
-        args['target'] = target
-        connection = args.get('ollama_serve_url', OllamaHandler.DEFAULT_SERVE_URL)
+        args = args["using"]
+        args["target"] = target
+        connection = args.get("ollama_serve_url", OllamaHandler.DEFAULT_SERVE_URL)
 
         def _model_check():
-            """ Checks model has been pulled and that it works correctly. """
+            """Checks model has been pulled and that it works correctly."""
             responses = {}
-            for endpoint in ['generate', 'embeddings']:
+            for endpoint in ["generate", "embeddings"]:
                 try:
                     code = requests.post(
-                        connection + f'/api/{endpoint}',
+                        connection + f"/api/{endpoint}",
                         json={
-                            'model': args['model_name'],
-                            'prompt': 'Hello.',
-                        }
+                            "model": args["model_name"],
+                            "prompt": "Hello.",
+                        },
                     ).status_code
                     responses[endpoint] = code
                 except Exception:
@@ -57,19 +59,21 @@ def _model_check():
         if 200 not in responses.values():
             # pull model (blocking operation) and serve
             # TODO: point to the engine storage folder instead of default location
-            connection = args.get('ollama_serve_url', OllamaHandler.DEFAULT_SERVE_URL)
-            requests.post(connection + '/api/pull', json={'name': args['model_name']})
+            connection = args.get("ollama_serve_url", OllamaHandler.DEFAULT_SERVE_URL)
+            requests.post(connection + "/api/pull", json={"name": args["model_name"]})
             # try one last time
             responses = _model_check()
             if 200 not in responses.values():
-                raise Exception(f"Ollama model `{args['model_name']}` is not working correctly. Please try pulling this model manually, check it works correctly and try again.")  # noqa
+                raise Exception(
+                    f"Ollama model `{args['model_name']}` is not working correctly. Please try pulling this model manually, check it works correctly and try again."
+                )  # noqa
 
         supported_modes = {k: True if v == 200 else False for k, v in responses.items()}
 
         # check if a mode has been provided and if it is valid
         runnable_modes = [mode for mode, supported in supported_modes.items() if supported]
-        if 'mode' in args:
-            if args['mode'] not in runnable_modes:
+        if "mode" in args:
+            if args["mode"] not in runnable_modes:
                 raise Exception(f"Mode `{args['mode']}` is not supported by the model `{args['model_name']}`.")
 
         # if a mode has not been provided, check if the model supports only one mode
@@ -77,11 +81,11 @@ def _model_check():
         # if it supports multiple modes, set the default mode to 'generate'
         else:
             if len(runnable_modes) == 1:
-                args['mode'] = runnable_modes[0]
+                args["mode"] = runnable_modes[0]
             else:
-                args['mode'] = 'generate'
+                args["mode"] = "generate"
 
-        self.model_storage.json_set('args', args)
+        self.model_storage.json_set("args", args)
 
     def predict(self, df: pd.DataFrame, args: Optional[Dict] = None) -> pd.DataFrame:
         """
@@ -93,50 +97,73 @@ def predict(self, df: pd.DataFrame, args: Optional[Dict] = None) -> pd.DataFrame
                 pd.DataFrame: The DataFrame containing row-wise text completions.
         """
         # setup
-        pred_args = args.get('predict_params', {})
-        args = self.model_storage.json_get('args')
-        model_name, target_col = args['model_name'], args['target']
-        prompt_template = pred_args.get('prompt_template',
-                                        args.get('prompt_template', 'Answer the following question: {{{{text}}}}'))
+        pred_args = args.get("predict_params", {})
+        args = self.model_storage.json_get("args")
+        model_name, target_col = args["model_name"], args["target"]
+
+        # Auto-detect column if template is missing
+        # If user provided a specific template
+        user_template = pred_args.get("prompt_template", args.get("prompt_template"))
+
+        # OR If no template and 'text' column is missing, then auto-detect
+        if user_template is None and "text" not in df.columns and len(df.columns) == 1:
+            col_name = df.columns[0]
+            # Create a template dynamically
+            prompt_template = "Answer the following question: {{{{" + col_name + "}}}}"
+        else:
+            # Fallback: Use user template OR default to 'text' (Old behavior)
+            prompt_template = user_template if user_template else "Answer the following question: {{{{text}}}}"
 
         # prepare prompts
         prompts, empty_prompt_ids = get_completed_prompts(prompt_template, df)
-        df['__mdb_prompt'] = prompts
+        df["__mdb_prompt"] = prompts
 
         # setup endpoint
-        endpoint = args.get('mode', 'generate')
+        endpoint = args.get("mode", "generate")
 
         # call llm
         completions = []
         for i, row in df.iterrows():
             if i not in empty_prompt_ids:
-                connection = args.get('ollama_serve_url', OllamaHandler.DEFAULT_SERVE_URL)
+                temperature = pred_args.get("temperature", args.get("temperature"))
+
+                # Options dictionary
+                options = {}
+                if temperature is not None:
+                    try:
+                        options["temperature"] = float(temperature)
+                    except ValueError:
+                        pass
+
+                # Calling API with the new options
+                connection = args.get("ollama_serve_url", OllamaHandler.DEFAULT_SERVE_URL)
                 raw_output = requests.post(
-                    connection + f'/api/{endpoint}',
+                    connection + f"/api/{endpoint}",
                     json={
-                        'model': model_name,
-                        'prompt': row['__mdb_prompt'],
-                    }
+                        "model": model_name,
+                        "prompt": row["__mdb_prompt"],
+                        "options": options,  # options passed here
+                    },
                 )
-                lines = raw_output.content.decode().split('\n')  # stream of output tokens
+                lines = raw_output.content.decode().split("\n")  # stream of output tokens
 
                 values = []
                 for line in lines:
-                    if line != '':
+                    if line != "":
                         info = json.loads(line)
-                        if 'response' in info:
-                            token = info['response']
+                        if "response" in info:
+                            token = info["response"]
                             values.append(token)
-                        elif 'embedding' in info:
-                            embedding = info['embedding']
+                        elif "embedding" in info:
+                            embedding = info["embedding"]
                             values.append(embedding)
 
-                if endpoint == 'embeddings':
+                if endpoint == "embeddings":
                     completions.append(values)
                 else:
-                    completions.append(''.join(values))
+                    completions.append("".join(values))
             else:
-                completions.append('')
+                completions.append("")
 
         # consolidate output
         data = pd.DataFrame(completions)
@@ -144,28 +171,32 @@ def predict(self, df: pd.DataFrame, args: Optional[Dict] = None) -> pd.DataFrame
         return data
 
     def describe(self, attribute: Optional[str] = None) -> pd.DataFrame:
-        args = self.model_storage.json_get('args')
-        model_name, target_col = args['model_name'], args['target']
-        prompt_template = args.get('prompt_template', 'Answer the following question: {{{{text}}}}')
+        args = self.model_storage.json_get("args")
+        model_name, target_col = args["model_name"], args["target"]
+        prompt_template = args.get("prompt_template", "Answer the following question: {{{{text}}}}")
 
         if attribute == "features":
-            return pd.DataFrame([[target_col, prompt_template]], columns=['target_column', 'mindsdb_prompt_template'])
+            return pd.DataFrame([[target_col, prompt_template]], columns=["target_column", "mindsdb_prompt_template"])
 
         # get model info
         else:
-            connection = args.get('ollama_serve_url', OllamaHandler.DEFAULT_SERVE_URL)
-            model_info = requests.post(connection + '/api/show', json={'name': model_name}).json()
-            return pd.DataFrame([[
-                model_name,
-                model_info.get('license', 'N/A'),
-                model_info.get('modelfile', 'N/A'),
-                model_info.get('parameters', 'N/A'),
-                model_info.get('template', 'N/A'),
-            ]],
+            connection = args.get("ollama_serve_url", OllamaHandler.DEFAULT_SERVE_URL)
+            model_info = requests.post(connection + "/api/show", json={"name": model_name}).json()
+            return pd.DataFrame(
+                [
+                    [
+                        model_name,
+                        model_info.get("license", "N/A"),
+                        model_info.get("modelfile", "N/A"),
+                        model_info.get("parameters", "N/A"),
+                        model_info.get("template", "N/A"),
+                    ]
+                ],
                 columns=[
-                    'model_type',
-                    'license',
-                    'modelfile',
-                    'parameters',
-                    'ollama_base_template',
-            ])
+                    "model_type",
+                    "license",
+                    "modelfile",
+                    "parameters",
+                    "ollama_base_template",
+                ],
+            )
diff --git a/mindsdb/integrations/handlers/ollama_handler/tests/test_ollama_handler.py b/mindsdb/integrations/handlers/ollama_handler/tests/test_ollama_handler.py
new file mode 100644
index 00000000000..b06caaae4e6
--- /dev/null
+++ b/mindsdb/integrations/handlers/ollama_handler/tests/test_ollama_handler.py
@@ -0,0 +1,45 @@
+import unittest
+from unittest.mock import patch, Mock
+import pandas as pd
+from mindsdb.integrations.handlers.ollama_handler.ollama_handler import OllamaHandler
+
+
+class TestOllamaHandler(unittest.TestCase):
+    def setUp(self):
+        # Mock the storage to return valid model configuration
+        mock_storage = Mock()
+        mock_storage.json_get.return_value = {
+            "model_name": "tinyllama",
+            "target": "response",
+            "ollama_serve_url": "http://localhost:11434",
+        }
+
+        # Initialize handler with mocked storage
+        self.handler = OllamaHandler(name="test_ollama", model_storage=mock_storage, engine_storage={})
+
+    @patch("mindsdb.integrations.handlers.ollama_handler.ollama_handler.requests.post")
+    def test_temperature_passing(self, mock_post):
+        """
+        Test that the temperature parameter is correctly extracted from args
+        and passed to the Ollama API options.
+        """
+        # Setup mock response
+        mock_response = Mock()
+        mock_response.content = b'{"response": "Test response"}'
+        mock_post.return_value = mock_response
+
+        # Create input dataframe
+        df = pd.DataFrame({"text": ["Hello"]})
+
+        # Execute prediction with temperature argument
+        self.handler.predict(df, args={"predict_params": {"temperature": 0.5}})
+
+        # Verify API call payload
+        call_args = mock_post.call_args[1]["json"]
+
+        self.assertIn("options", call_args)
+        self.assertEqual(call_args["options"]["temperature"], 0.5)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/mindsdb/integrations/handlers/openbb_handler/openbb_tables.py b/mindsdb/integrations/handlers/openbb_handler/openbb_tables.py
index 69cf5631ecc..e3002d0cd45 100644
--- a/mindsdb/integrations/handlers/openbb_handler/openbb_tables.py
+++ b/mindsdb/integrations/handlers/openbb_handler/openbb_tables.py
@@ -8,6 +8,7 @@
 
 from typing import Dict, List, Union
 from pydantic import ValidationError
+import ast as py_ast
 
 import pandas as pd
 
@@ -15,6 +16,48 @@
 
 
 class OpenBBtable(APITable):
+    def _resolve_openbb_command(self, cmd: str):
+        """Resolve a validated OpenBB command to a callable."""
+        if not isinstance(cmd, str):
+            raise TypeError("OpenBB command must be a string.")
+
+        parts = cmd.split(".")
+        if len(parts) < 2 or parts[0] != "obb":
+            raise ValueError("OpenBB command must start with 'obb.'")
+
+        target = self.handler
+        for part in parts:
+            if not part.isidentifier() or part.startswith("_"):
+                raise ValueError(f"Invalid OpenBB command segment: {part}")
+            target = getattr(target, part)
+
+        if not callable(target):
+            raise TypeError(f"OpenBB command '{cmd}' is not callable.")
+
+        return target
+
+    def _coerce_param_value(self, value):
+        """Coerce string literals to Python values while keeping plain strings intact."""
+        if not isinstance(value, str):
+            return value
+
+        candidate = value.strip()
+        if candidate == "":
+            return value
+
+        lowered = candidate.lower()
+        if lowered == "true":
+            return True
+        if lowered == "false":
+            return False
+        if lowered in ("none", "null"):
+            return None
+
+        try:
+            return py_ast.literal_eval(candidate)
+        except (ValueError, SyntaxError):
+            return value
+
     def _get_params_from_conditions(self, conditions: List) -> Dict:
         """Gets aggregate trade data API params from SQL WHERE conditions.
 
@@ -73,24 +116,16 @@ def select(self, query: ast.Select) -> pd.DataFrame:
             # Ensure that the cmd provided is a valid OpenBB command
             available_cmds = [f"obb{cmd}" for cmd in list(self.handler.obb.coverage.commands.keys())]
             if cmd not in available_cmds:
-                logger.error(f"The command provided is not supported by OpenBB! Choose one of the following: {', '.join(available_cmds)}")
-                raise Exception(f"The command provided is not supported by OpenBB! Choose one of the following: {', '.join(available_cmds)}")
-
-            args = ""
-            # If there are parameters create arguments as a string
-            if params:
-                for arg, val in params.items():
-                    args += f"{arg}={val},"
+                logger.error(
+                    f"The command provided is not supported by OpenBB! Choose one of the following: {', '.join(available_cmds)}"
+                )
+                raise Exception(
+                    f"The command provided is not supported by OpenBB! Choose one of the following: {', '.join(available_cmds)}"
+                )
 
-                # Remove the additional ',' added at the end
-                if args:
-                    args = args[:-1]
-
-            # Recreate the OpenBB command with the arguments
-            openbb_cmd = f"self.handler.{cmd}({args})"
-
-            # Execute the OpenBB command and return the OBBject
-            openbb_object = eval(openbb_cmd)
+            # Resolve command safely and invoke with explicit keyword args.
+            openbb_function = self._resolve_openbb_command(cmd)
+            openbb_object = openbb_function(**{key: self._coerce_param_value(val) for key, val in params.items()})
 
             # Transform the OBBject into a pandas DataFrame
             data = openbb_object.to_df()
@@ -109,16 +144,12 @@ def select(self, query: ast.Select) -> pd.DataFrame:
         return data
 
 
-def create_table_class(
-    params_metadata,
-    response_metadata,
-    obb_function,
-    func_docs="",
-    provider=None
-):
+def create_table_class(params_metadata, response_metadata, obb_function, func_docs="", provider=None):
     """Creates a table class for the given OpenBB Platform function."""
-    mandatory_fields = [key for key in params_metadata['fields'].keys() if params_metadata['fields'][key].is_required() is True]
-    response_columns = list(response_metadata['fields'].keys())
+    mandatory_fields = [
+        key for key in params_metadata["fields"].keys() if params_metadata["fields"][key].is_required() is True
+    ]
+    response_columns = list(response_metadata["fields"].keys())
 
     class AnyTable(APITable):
         def _get_params_from_conditions(self, conditions: List) -> Dict:
@@ -152,44 +183,43 @@ def select(self, query: ast.Select) -> pd.DataFrame:
 
             params = {}
             if provider is not None:
-                params['provider'] = provider
+                params["provider"] = provider
 
             filters = []
             mandatory_args_set = {key: False for key in mandatory_fields}
             columns_to_add = {}
-            strict_filter = arg_params.get('strict_filter', False)
+            strict_filter = arg_params.get("strict_filter", False)
 
             for op, arg1, arg2 in conditions:
-                if op == 'or':
-                    raise NotImplementedError('OR is not supported')
+                if op == "or":
+                    raise NotImplementedError("OR is not supported")
 
                 if arg1 in mandatory_fields:
                     mandatory_args_set[arg1] = True
 
-                if ('start_' + arg1 in params_metadata['fields'] and arg1 in response_columns and arg2 is not None):
-
-                    if response_metadata['fields'][arg1].annotation == 'datetime':
+                if "start_" + arg1 in params_metadata["fields"] and arg1 in response_columns and arg2 is not None:
+                    if response_metadata["fields"][arg1].annotation == "datetime":
                         date = parse_local_date(arg2)
-                        interval = arg_params.get('interval', '1d')
+                        interval = arg_params.get("interval", "1d")
 
-                        if op == '>':
-                            params['start_' + arg1] = date.strftime('%Y-%m-%d')
-                        elif op == '<':
-                            params['end_' + arg1] = date.strftime('%Y-%m-%d')
-                        elif op == '>=':
+                        if op == ">":
+                            params["start_" + arg1] = date.strftime("%Y-%m-%d")
+                        elif op == "<":
+                            params["end_" + arg1] = date.strftime("%Y-%m-%d")
+                        elif op == ">=":
                             date = date - pd.Timedelta(interval)
-                            params['start_' + arg1] = date.strftime('%Y-%m-%d')
-                        elif op == '<=':
+                            params["start_" + arg1] = date.strftime("%Y-%m-%d")
+                        elif op == "<=":
                             date = date + pd.Timedelta(interval)
-                            params['end_' + arg1] = date.strftime('%Y-%m-%d')
-                        elif op == '=':
+                            params["end_" + arg1] = date.strftime("%Y-%m-%d")
+                        elif op == "=":
                             date = date - pd.Timedelta(interval)
-                            params['start_' + arg1] = date.strftime('%Y-%m-%d')
+                            params["start_" + arg1] = date.strftime("%Y-%m-%d")
                             date = date + pd.Timedelta(interval)
-                            params['end_' + arg1] = date.strftime('%Y-%m-%d')
+                            params["end_" + arg1] = date.strftime("%Y-%m-%d")
 
-                elif arg1 in params_metadata['fields'] or not strict_filter:
-                    if op == '=':
+                elif arg1 in params_metadata["fields"] or not strict_filter:
+                    if op == "=":
                         params[arg1] = arg2
                         columns_to_add[arg1] = arg2
 
@@ -201,9 +231,9 @@ def select(self, query: ast.Select) -> pd.DataFrame:
 
                 # Create docstring for the current function
                 text += "\nDocstring:"
-                for param in params_metadata['fields']:
-                    field = params_metadata['fields'][param]
-                    if getattr(field.annotation, '__origin__', None) is Union:
+                for param in params_metadata["fields"]:
+                    field = params_metadata["fields"][param]
+                    if getattr(field.annotation, "__origin__", None) is Union:
                         annotation = f"Union[{', '.join(arg.__name__ for arg in field.annotation.__args__)}]"
                     else:
                         annotation = field.annotation.__name__
@@ -215,8 +245,8 @@ def select(self, query: ast.Select) -> pd.DataFrame:
 
             try:
                 # Handle limit keyword correctly since it can't be parsed as a WHERE arg (i.e. WHERE limit = 50)
-                if query.limit is not None and 'limit' in params_metadata['fields']:
-                    params['limit'] = query.limit.value
+                if query.limit is not None and "limit" in params_metadata["fields"]:
+                    params["limit"] = query.limit.value
                 obbject = obb_function(**params)
 
                 # Extract data in dataframe format
@@ -273,13 +303,13 @@ def select(self, query: ast.Select) -> pd.DataFrame:
                 return result
 
             except AttributeError as e:
-                logger.info(f'Encountered error while executing OpenBB select: {str(e)}')
+                logger.info(f"Encountered error while executing OpenBB select: {str(e)}")
 
                 # Create docstring for the current function
                 text = "Docstring:"
-                for param in params_metadata['fields']:
-                    field = params_metadata['fields'][param]
-                    if getattr(field.annotation, '__origin__', None) is Union:
+                for param in params_metadata["fields"]:
+                    field = params_metadata["fields"][param]
+                    if getattr(field.annotation, "__origin__", None) is Union:
                         annotation = f"Union[{', '.join(arg.__name__ for arg in field.annotation.__args__)}]"
                     else:
                         annotation = field.annotation.__name__
@@ -290,13 +320,13 @@ def select(self, query: ast.Select) -> pd.DataFrame:
                 raise Exception(f"{str(e)}\n\n{text}.") from e
 
             except ValidationError as e:
-                logger.info(f'Encountered error while executing OpenBB select: {str(e)}')
+                logger.info(f"Encountered error while executing OpenBB select: {str(e)}")
 
                 # Create docstring for the current function
                 text = "Docstring:"
-                for param in params_metadata['fields']:
-                    field = params_metadata['fields'][param]
-                    if getattr(field.annotation, '__origin__', None) is Union:
+                for param in params_metadata["fields"]:
+                    field = params_metadata["fields"][param]
+                    if getattr(field.annotation, "__origin__", None) is Union:
                         annotation = f"Union[{', '.join(arg.__name__ for arg in field.annotation.__args__)}]"
                     else:
                         annotation = field.annotation.__name__
@@ -307,21 +337,25 @@ def select(self, query: ast.Select) -> pd.DataFrame:
                 raise Exception(f"{str(e)}\n\n{text}.") from e
 
             except Exception as e:
-                logger.info(f'Encountered error while executing OpenBB select: {str(e)}')
+                logger.info(f"Encountered error while executing OpenBB select: {str(e)}")
 
                 #  TODO: This one doesn't work because it's taken care of from MindsDB side
                 if "Table not found" in str(e):
-                    raise Exception(f"{str(e)}\n\nCheck if the method exists here: {func_docs}.\n\n  -  If it doesn't you may need to look for the parent module to check whether there's a typo in the naming.\n- If it does you may need to install a new extension to the OpenBB Platform, and you can see what is available at https://my.openbb.co/app/platform/extensions.") from e
+                    raise Exception(
+                        f"{str(e)}\n\nCheck if the method exists here: {func_docs}.\n\n  -  If it doesn't you may need to look for the parent module to check whether there's a typo in the naming.\n- If it does you may need to install a new extension to the OpenBB Platform, and you can see what is available at https://my.openbb.co/app/platform/extensions."
+                    ) from e
 
                 if "Missing credential" in str(e):
-                    raise Exception(f"{str(e)}\n\nGo to https://my.openbb.co/app/platform/api-keys to set this API key, for free.") from e
+                    raise Exception(
+                        f"{str(e)}\n\nGo to https://my.openbb.co/app/platform/api-keys to set this API key, for free."
+                    ) from e
 
                 # Catch all other errors
                 # Create docstring for the current function
                 text = "Docstring:"
-                for param in params_metadata['fields']:
-                    field = params_metadata['fields'][param]
-                    if getattr(field.annotation, '__origin__', None) is Union:
+                for param in params_metadata["fields"]:
+                    field = params_metadata["fields"][param]
+                    if getattr(field.annotation, "__origin__", None) is Union:
                         annotation = f"Union[{', '.join(arg.__name__ for arg in field.annotation.__args__)}]"
                     else:
                         annotation = field.annotation.__name__
diff --git a/mindsdb/integrations/handlers/oracle_handler/oracle_handler.py b/mindsdb/integrations/handlers/oracle_handler/oracle_handler.py
index ad9c4cde578..79d4c342ff4 100644
--- a/mindsdb/integrations/handlers/oracle_handler/oracle_handler.py
+++ b/mindsdb/integrations/handlers/oracle_handler/oracle_handler.py
@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional, Text
+from typing import Any, Generator
 
 import oracledb
 import pandas as pd
@@ -10,9 +10,15 @@
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
     RESPONSE_TYPE,
+    TableResponse,
+    OkResponse,
+    ErrorResponse,
+    DataHandlerResponse,
 )
 from mindsdb.utilities import log
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb.utilities.config import config as mindsdb_config
+from mindsdb.utilities.types.column import Column
 import mindsdb.utilities.profiler as profiler
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
@@ -80,43 +86,43 @@ def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
     return MYSQL_DATA_TYPE.VARCHAR
 
 
-def _make_table_response(result: list[tuple[Any]], cursor: Cursor) -> Response:
-    """Build response from result and cursor.
+def _get_colums(cursor: Cursor) -> list[Column]:
+    """Get columns from cursor.
 
     Args:
-        result (list[tuple[Any]]): result of the query.
-        cursor (oracledb.Cursor): cursor object.
+        cursor (psycopg.Cursor): cursor object.
 
     Returns:
-        Response: response object.
+        List of columns
     """
-    description: list[tuple[Any]] = cursor.description
-    mysql_types: list[MYSQL_DATA_TYPE] = []
-    for column in description:
+    columns = []
+    for column in cursor.description:
+        column_name = column[0]
         db_type = column[1]
         precision = column[4]
         scale = column[5]
+        mysql_type = None
         if db_type is oracledb.DB_TYPE_JSON:
-            mysql_types.append(MYSQL_DATA_TYPE.JSON)
+            mysql_type = MYSQL_DATA_TYPE.JSON
         elif db_type is oracledb.DB_TYPE_VECTOR:
-            mysql_types.append(MYSQL_DATA_TYPE.VECTOR)
+            mysql_type = MYSQL_DATA_TYPE.VECTOR
         elif db_type is oracledb.DB_TYPE_NUMBER:
             if scale != 0:
-                mysql_types.append(MYSQL_DATA_TYPE.FLOAT)
+                mysql_type = MYSQL_DATA_TYPE.FLOAT
             else:
                 # python max int is 19 digits, oracle can return more
                 if precision > 18:
-                    mysql_types.append(MYSQL_DATA_TYPE.DECIMAL)
+                    mysql_type = MYSQL_DATA_TYPE.DECIMAL
                 else:
-                    mysql_types.append(MYSQL_DATA_TYPE.INT)
+                    mysql_type = MYSQL_DATA_TYPE.INT
         elif db_type is oracledb.DB_TYPE_BINARY_FLOAT:
-            mysql_types.append(MYSQL_DATA_TYPE.FLOAT)
+            mysql_type = MYSQL_DATA_TYPE.FLOAT
         elif db_type is oracledb.DB_TYPE_BINARY_DOUBLE:
-            mysql_types.append(MYSQL_DATA_TYPE.FLOAT)
+            mysql_type = MYSQL_DATA_TYPE.FLOAT
         elif db_type is oracledb.DB_TYPE_BINARY_INTEGER:
-            mysql_types.append(MYSQL_DATA_TYPE.INT)
+            mysql_type = MYSQL_DATA_TYPE.INT
         elif db_type is oracledb.DB_TYPE_BOOLEAN:
-            mysql_types.append(MYSQL_DATA_TYPE.BOOLEAN)
+            mysql_type = MYSQL_DATA_TYPE.BOOLEAN
         elif db_type in (
             oracledb.DB_TYPE_CHAR,
             oracledb.DB_TYPE_NCHAR,
@@ -125,22 +131,35 @@ def _make_table_response(result: list[tuple[Any]], cursor: Cursor) -> Response:
             oracledb.DB_TYPE_VARCHAR,
             oracledb.DB_TYPE_LONG_NVARCHAR,
         ):
-            mysql_types.append(MYSQL_DATA_TYPE.TEXT)
+            mysql_type = MYSQL_DATA_TYPE.TEXT
         elif db_type in (oracledb.DB_TYPE_RAW, oracledb.DB_TYPE_LONG_RAW):
-            mysql_types.append(MYSQL_DATA_TYPE.BINARY)
+            mysql_type = MYSQL_DATA_TYPE.BINARY
         elif db_type is oracledb.DB_TYPE_DATE:
-            mysql_types.append(MYSQL_DATA_TYPE.DATE)
+            mysql_type = MYSQL_DATA_TYPE.DATE
         elif db_type is oracledb.DB_TYPE_TIMESTAMP:
-            mysql_types.append(MYSQL_DATA_TYPE.TIMESTAMP)
+            mysql_type = MYSQL_DATA_TYPE.TIMESTAMP
         else:
             # fallback
-            mysql_types.append(MYSQL_DATA_TYPE.TEXT)
+            mysql_type = MYSQL_DATA_TYPE.TEXT
+
+        columns.append(Column(name=column_name, type=mysql_type))
+    return columns
+
+
+def _make_df(result: list[tuple[Any]], columns: list[Column]) -> pd.DataFrame:
+    """Make pandas DataFrame from result and columns.
+
+    Args:
+        result (list[tuple[Any]]): result of the query.
+        columns (list[Column]): list of columns.
 
-    # region cast int and bool to nullable types
+    Returns:
+        pd.DataFrame: pandas DataFrame.
+    """
     serieses = []
-    for i, mysql_type in enumerate(mysql_types):
+    for i, column in enumerate(columns):
         expected_dtype = None
-        if mysql_type in (
+        if column.type in (
             MYSQL_DATA_TYPE.SMALLINT,
             MYSQL_DATA_TYPE.INT,
             MYSQL_DATA_TYPE.MEDIUMINT,
@@ -148,13 +167,11 @@ def _make_table_response(result: list[tuple[Any]], cursor: Cursor) -> Response:
             MYSQL_DATA_TYPE.TINYINT,
         ):
             expected_dtype = "Int64"
-        elif mysql_type in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
+        elif column.type in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
             expected_dtype = "boolean"
-        serieses.append(pd.Series([row[i] for row in result], dtype=expected_dtype, name=description[i][0]))
+        serieses.append(pd.Series([row[i] for row in result], dtype=expected_dtype, name=column.name))
     df = pd.concat(serieses, axis=1, copy=False)
-    # endregion
-
-    return Response(RESPONSE_TYPE.TABLE, data_frame=df, mysql_types=mysql_types)
+    return df
 
 
 class OracleHandler(MetaDatabaseHandler):
@@ -163,14 +180,15 @@ class OracleHandler(MetaDatabaseHandler):
     """
 
     name = "oracle"
+    stream_response = True
 
-    def __init__(self, name: Text, connection_data: Optional[Dict], **kwargs) -> None:
+    def __init__(self, name: str, connection_data: dict | None, **kwargs) -> None:
         """
         Initializes the handler.
 
         Args:
-            name (Text): The name of the handler instance.
-            connection_data (Dict): The connection data required to connect to OracleDB.
+            name (str): The name of the handler instance.
+            connection_data (dict | None): The connection data required to connect to OracleDB.
             kwargs: Arbitrary keyword arguments.
         """
         super().__init__(name)
@@ -304,78 +322,99 @@ def check_connection(self) -> StatusResponse:
 
         return response
 
-    @profiler.profile()
-    def native_query(self, query: Text) -> Response:
-        """
-        Executes a SQL query on the Oracle database and returns the result.
+    def native_query(self, query: str, stream: bool = True, **kwargs) -> TableResponse | OkResponse | ErrorResponse:
+        """Executes a SQL query on the Oracle database and returns the result.
 
         Args:
-            query (Text): The SQL query to be executed.
+            query (str): The SQL query to be executed.
+            stream (bool): Whether to execute the query on the server side (streaming).
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            Response: A response object containing the result of the query or an error message.
+            TableResponse | OkResponse | ErrorResponse: A response object containing the result of the query or an error message.
         """
-        need_to_close = self.is_connected is False
+        if stream is False:
+            response = self._execute_fetchall(query, **kwargs)
+        else:
+            generator = self._execute_fetchmany(query, **kwargs)
+            try:
+                response: TableResponse = next(generator)
+                response.data_generator = generator
+            except StopIteration as e:
+                response = e.value
+                if isinstance(response, DataHandlerResponse) is False:
+                    raise
+        return response
 
+    def _execute_fetchmany(self, query: str) -> Generator[pd.DataFrame, None, OkResponse | ErrorResponse]:
         connection = self.connect()
-        with connection.cursor() as cur:
+        with connection.cursor() as cursor:
             try:
-                cur.execute(query)
-                if cur.description is None:
-                    response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
-                else:
-                    result = cur.fetchall()
-                    response = _make_table_response(result, cur)
-                connection.commit()
-            except DatabaseError as database_error:
-                logger.error(f"Error running query: {query} on Oracle, {database_error}!")
-                response = Response(
-                    RESPONSE_TYPE.ERROR,
-                    error_message=str(database_error),
-                )
-                connection.rollback()
+                # Configure cursor for optimal server-side streaming
+                fetch_size = mindsdb_config["data_stream"]["fetch_size"]
+                cursor.arraysize = fetch_size
 
-            except Exception as unknown_error:
-                logger.error(f"Unknwon error running query: {query} on Oracle, {unknown_error}!")
-                response = Response(
-                    RESPONSE_TYPE.ERROR,
-                    error_message=str(unknown_error),
-                )
-                connection.rollback()
+                cursor.execute(query)
 
-        if need_to_close is True:
-            self.disconnect()
-        return response
+                if cursor.description is None:
+                    connection.commit()
+                    return OkResponse(affected_rows=cursor.rowcount)
 
-    def query_stream(self, query: ASTNode, fetch_size: int = 1000):
-        """
-        Executes a SQL query represented by an ASTNode and retrieves the data in a streaming fashion.
+                columns = _get_colums(cursor)
+                yield TableResponse(affected_rows=cursor.rowcount, columns=columns)
+                # Stream data in batches
+                while result := cursor.fetchmany(cursor.arraysize):
+                    yield _make_df(result, columns)
+                connection.commit()
+            except Exception as e:
+                return self._handle_query_exception(e, query, connection)
+
+    def _execute_fetchall(self, query: str) -> DataHandlerResponse:
+        """Executes a SQL query and fetches all results at once (client-side).
 
         Args:
-            query (ASTNode): An ASTNode representing the SQL query to be executed.
-            fetch_size (int): The number of rows to fetch in each batch.
-        Yields:
-            pd.DataFrame: A DataFrame containing a batch of rows from the query result.
-            Response: In case of an error, yields a Response object with the error details.
-        """
-        query_str = SqlalchemyRender("oracle").get_string(query, with_failback=True)
-        need_to_close = self.is_connected is False
+            query (str): The SQL query to be executed.
 
+        Returns:
+            TableResponse | OkResponse | ErrorResponse: A response object containing the result of the query or an error message.
+        """
         connection = self.connect()
-        with connection.cursor() as cur:
+        with connection.cursor() as cursor:
             try:
-                cur.execute(query_str)
-                while True:
-                    result = cur.fetchmany(fetch_size)
-                    if not result:
-                        break
-                    df = pd.DataFrame(result, columns=[col[0] for col in cur.description])
-                    yield df
+                cursor.execute(query)
+                if cursor.description is None:
+                    response = OkResponse(affected_rows=cursor.rowcount)
+                else:
+                    # Fetch all results at once
+                    result = cursor.fetchall()
+                    columns = _get_colums(cursor)
+                    df = _make_df(result, columns)
+                    response = TableResponse(data=df, affected_rows=cursor.rowcount, columns=columns)
                 connection.commit()
-            finally:
-                connect
-        if need_to_close is True:
-            self.disconnect()
+            except Exception as e:
+                response = self._handle_query_exception(e, query, connection)
+
+        return response
+
+    def _handle_query_exception(self, e: Exception, query: str, connection) -> ErrorResponse:
+        """Handle query execution errors with appropriate logging and rollback.
+
+        Args:
+            e: The exception that was raised
+            query: The SQL query that failed
+            connection: The database connection to rollback
+
+        Returns:
+            ErrorResponse with appropriate error details
+        """
+        if isinstance(e, DatabaseError):
+            logger.error(f"Error running query: {query} on Oracle, {e}!")
+            connection.rollback()
+            return ErrorResponse(error_code=0, error_message=str(e))
+
+        logger.error(f"Unknown error running query: {query} on Oracle, {e}!")
+        connection.rollback()
+        return ErrorResponse(error_code=0, error_message=str(e))
 
     def insert(self, table_name: str, df: pd.DataFrame) -> Response:
         """
@@ -454,12 +493,12 @@ def get_tables(self) -> Response:
             """
         return self.native_query(query)
 
-    def get_columns(self, table_name: Text) -> Response:
+    def get_columns(self, table_name: str) -> Response:
         """
         Retrieves column details for a specified table in the Oracle database.
 
         Args:
-            table_name (Text): The name of the table for which to retrieve column information.
+            table_name (str): The name of the table for which to retrieve column information.
 
         Returns:
             Response: A response object containing the column details, formatted as per the `Response` class.
@@ -485,11 +524,11 @@ def get_columns(self, table_name: Text) -> Response:
             ORDER BY TABLE_NAME, COLUMN_ID
         """
         result = self.native_query(query)
-        if result.resp_type is RESPONSE_TYPE.TABLE:
+        if result.type is RESPONSE_TYPE.TABLE:
             result.to_columns_table_response(map_type_fn=_map_type)
         return result
 
-    def meta_get_tables(self, table_names: Optional[List[str]]) -> Response:
+    def meta_get_tables(self, table_names: list[str] | None) -> Response:
         """
         Retrieves metadata about all non-system tables and views accessible to the current user.
 
@@ -524,11 +563,11 @@ def meta_get_tables(self, table_names: Optional[List[str]]) -> Response:
         result = self.native_query(query)
         return result
 
-    def meta_get_columns(self, table_names: Optional[List[str]]) -> Response:
+    def meta_get_columns(self, table_names: list[str] | None) -> Response:
         """Retrieves metadata about the columns of specified tables accessible to the current user.
 
         Args:
-            table_names (list[str]): A list of table names for which to retrieve column metadata.
+            table_names (list[str] | None): A list of table names for which to retrieve column metadata.
 
         Returns:
             Response: A response object containing column metadata.
@@ -564,11 +603,11 @@ def meta_get_columns(self, table_names: Optional[List[str]]) -> Response:
         result = self.native_query(query)
         return result
 
-    def meta_get_column_statistics(self, table_names: Optional[List[str]]) -> Response:
+    def meta_get_column_statistics(self, table_names: list[str] | None) -> Response:
         """Retrieves statistics about the columns of specified tables accessible to the current user.
 
         Args:
-            table_names (list[str]): A list of table names for which to retrieve column statistics.
+            table_names (list[str] | None): A list of table names for which to retrieve column statistics.
 
         Returns:
             Response: A response object containing column statistics.
@@ -623,12 +662,12 @@ def meta_get_column_statistics(self, table_names: Optional[List[str]]) -> Respon
 
         result = self.native_query(query)
 
-        if result.resp_type is RESPONSE_TYPE.TABLE and result.data_frame is not None:
+        if result.type is RESPONSE_TYPE.TABLE and result.data_frame is not None:
             df = result.data_frame
 
             def extract_min_max(
                 histogram_str: str,
-            ) -> tuple[Optional[float], Optional[float]]:
+            ) -> tuple[float | None, float | None]:
                 if histogram_str and str(histogram_str).lower() not in ["nan", "none"]:
                     values = str(histogram_str).split(",")
                     if values:
@@ -643,12 +682,12 @@ def extract_min_max(
             df.drop(columns=["HISTOGRAM_BOUNDS"], inplace=True)
         return result
 
-    def meta_get_primary_keys(self, table_names: Optional[List[str]]) -> Response:
+    def meta_get_primary_keys(self, table_names: list[str] | None) -> Response:
         """
         Retrieves the primary keys for the specified tables accessible to the current user.
 
         Args:
-            table_names (list[str]): A list of table names for which to retrieve primary keys.
+            table_names (list[str] | None): A list of table names for which to retrieve primary keys.
 
         Returns:
             Response: A response object containing primary key information.
@@ -681,12 +720,12 @@ def meta_get_primary_keys(self, table_names: Optional[List[str]]) -> Response:
         result = self.native_query(query)
         return result
 
-    def meta_get_foreign_keys(self, table_names: Optional[List[str]]) -> Response:
+    def meta_get_foreign_keys(self, table_names: list[str] | None) -> Response:
         """
         Retrieves the foreign keys for the specified tables accessible to the current user.
 
         Args:
-            table_names (list[str]): A list of table names for which to retrieve foreign keys.
+            table_names (list[str] | None): A list of table names for which to retrieve foreign keys.
 
         Returns:
             Response: A response object containing foreign key information.
diff --git a/mindsdb/integrations/handlers/pgvector_handler/pgvector_handler.py b/mindsdb/integrations/handlers/pgvector_handler/pgvector_handler.py
index ab9aac0b340..5d24c3b5578 100644
--- a/mindsdb/integrations/handlers/pgvector_handler/pgvector_handler.py
+++ b/mindsdb/integrations/handlers/pgvector_handler/pgvector_handler.py
@@ -2,7 +2,7 @@
 import json
 import hashlib
 from collections import OrderedDict
-from typing import Dict, List, Literal, Tuple
+from typing import List, Literal, Tuple
 from urllib.parse import urlparse
 
 import pandas as pd
@@ -32,7 +32,6 @@
 from mindsdb.integrations.libs.vectordatabase_handler import (
     FilterCondition,
     VectorStoreHandler,
-    DistanceFunction,
     TableField,
     FilterOperator,
 )
@@ -131,7 +130,7 @@ def query(self, query: ASTNode) -> Response:
         if isinstance(query, DropTables):
             query.tables = [self._check_table(table.parts[-1]) for table in query.tables]
             query_str, params = self.renderer.get_exec_params(query, with_failback=True)
-            return self.native_query(query_str, params, no_restrict=True)
+            return self.native_query(query_str, params, no_restrict=True, stream=False)
         return super().query(query)
 
     def native_query(self, query, params=None, no_restrict=False) -> Response:
@@ -146,7 +145,7 @@ def native_query(self, query, params=None, no_restrict=False) -> Response:
         return super().native_query(query, params=params)
 
     def raw_query(self, query, params=None) -> Response:
-        resp = super().native_query(query, params)
+        resp = super().native_query(query, params, stream=False)
         if resp.resp_type == RESPONSE_TYPE.ERROR:
             raise RuntimeError(resp.error_message)
         if resp.resp_type == RESPONSE_TYPE.TABLE:
@@ -527,118 +526,6 @@ def keyword_select(
 
         return result
 
-    def hybrid_search(
-        self,
-        table_name: str,
-        embeddings: List[float],
-        query: str = None,
-        metadata: Dict[str, str] = None,
-        distance_function=DistanceFunction.COSINE_DISTANCE,
-        **kwargs,
-    ) -> pd.DataFrame:
-        """
-        Executes a hybrid search, combining semantic search and one or both of keyword/metadata search.
-
-        For insight on the query construction, see: https://docs.pgvecto.rs/use-case/hybrid-search.html#advanced-search-merge-the-results-of-full-text-search-and-vector-search.
-
-        Args:
-            table_name(str): Name of underlying table containing content, embeddings, & metadata
-            embeddings(List[float]): Embedding vector to perform semantic search against
-            query(str): User query to convert into keywords for keyword search
-            metadata(Dict[str, str]): Metadata filters to filter content rows against
-            distance_function(DistanceFunction): Distance function used to compare embeddings vectors for semantic search
-
-        Kwargs:
-            id_column_name(str): Name of ID column in underlying table
-            content_column_name(str): Name of column containing document content in underlying table
-            embeddings_column_name(str): Name of column containing embeddings vectors in underlying table
-            metadata_column_name(str): Name of column containing metadata key-value pairs in underlying table
-
-        Returns:
-            df(pd.DataFrame): Hybrid search result, sorted by hybrid search rank
-        """
-        if query is None and metadata is None:
-            raise ValueError(
-                "Must provide at least one of: query for keyword search, or metadata filters. For only embeddings search, use normal search instead."
-            )
-
-        id_column_name = kwargs.get("id_column_name", "id")
-        content_column_name = kwargs.get("content_column_name", "content")
-        embeddings_column_name = kwargs.get("embeddings_column_name", "embeddings")
-        metadata_column_name = kwargs.get("metadata_column_name", "metadata")
-        # Filter by given metadata for semantic search & full text search CTEs, if present.
-        where_clause = " WHERE "
-        if metadata is None:
-            where_clause = ""
-            metadata = {}
-        for i, (k, v) in enumerate(metadata.items()):
-            where_clause += f"{metadata_column_name}->>'{k}' = '{v}'"
-            if i < len(metadata.items()) - 1:
-                where_clause += " AND "
-
-        # See https://docs.pgvecto.rs/use-case/hybrid-search.html#advanced-search-merge-the-results-of-full-text-search-and-vector-search.
-        #
-        # We can break down the below query as follows:
-        #
-        # Start with a CTE (Common Table Expression) called semantic_search (https://www.postgresql.org/docs/current/queries-with.html).
-        # This expression calculates rank by the defined distance function, which measures the distance between the
-        # embeddings column and the given embeddings vector. Results are ordered by this rank.
-        #
-        # Next, define another CTE called full_text_search if we are doing keyword search.
-        # This calculates rank using the built-in ts_rank function (https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-RANKING).
-        # We convert the content column to a ts_vector and match rows for the given tsquery in the content column. Results are ordered by this ts_rank.
-        #
-        # For both of these CTEs, we filter by any given metadata fields.
-        #
-        # See https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-DOCUMENTS for to_tsvector
-        # See https://www.postgresql.org/docs/current/functions-textsearch.html#FUNCTIONS-TEXTSEARCH for tsquery syntax
-        #
-        # Finally, we use a FULL OUTER JOIN to SELECT from both CTEs defined above.
-        # The COALESCE function is used to handle cases where one CTE has null values.
-        #
-        # Or, if we are only doing metadata search, we leave out the JOIN & full text search CTEs.
-        #
-        # We calculate the final "hybrid" rank by summing the reciprocals of the ranks from each individual CTE.
-        semantic_search_cte = f"""WITH semantic_search AS (
-    SELECT {id_column_name}, {content_column_name}, {embeddings_column_name},
-    RANK () OVER (ORDER BY {embeddings_column_name} {distance_function.value} '{str(embeddings)}') AS rank
-    FROM "{table_name}" {where_clause}
-    ORDER BY {embeddings_column_name} {distance_function.value} '{str(embeddings)}'::vector
-    )"""
-
-        full_text_search_cte = ""
-        if query is not None:
-            ts_vector_clause = (
-                f"WHERE to_tsvector('english', {content_column_name}) @@ plainto_tsquery('english', '{query}')"
-            )
-            if metadata:
-                ts_vector_clause = (
-                    f"AND to_tsvector('english', {content_column_name}) @@ plainto_tsquery('english', '{query}')"
-                )
-            full_text_search_cte = f""",
-    full_text_search AS (
-    SELECT {id_column_name}, {content_column_name}, {embeddings_column_name},
-    RANK () OVER (ORDER BY ts_rank(to_tsvector('english', {content_column_name}), plainto_tsquery('english', '{query}')) DESC) AS rank
-    FROM "{table_name}" {where_clause}
-    {ts_vector_clause}
-    ORDER BY ts_rank(to_tsvector('english', {content_column_name}), plainto_tsquery('english', '{query}')) DESC
-    )"""
-
-        hybrid_select = """
-    SELECT * FROM semantic_search"""
-        if query is not None:
-            hybrid_select = f"""
-    SELECT
-        COALESCE(semantic_search.{id_column_name}, full_text_search.{id_column_name}) AS id,
-        COALESCE(semantic_search.{content_column_name}, full_text_search.{content_column_name}) AS content,
-        COALESCE(semantic_search.{embeddings_column_name}, full_text_search.{embeddings_column_name}) AS embeddings,
-        COALESCE(1.0 / (1 + semantic_search.rank), 0.0) + COALESCE(1.0 / (1 + full_text_search.rank), 0.0) AS rank
-    FROM semantic_search FULL OUTER JOIN full_text_search USING ({id_column_name}) ORDER BY rank DESC;
-        """
-
-        full_search_query = f"{semantic_search_cte}{full_text_search_cte}{hybrid_select}"
-        return self.raw_query(full_search_query)
-
     def create_table(self, table_name: str):
         """Create a table with a vector column."""
 
diff --git a/mindsdb/integrations/handlers/pgvector_handler/requirements.txt b/mindsdb/integrations/handlers/pgvector_handler/requirements.txt
index 1047dcfb1f5..92ec66f21ce 100644
--- a/mindsdb/integrations/handlers/pgvector_handler/requirements.txt
+++ b/mindsdb/integrations/handlers/pgvector_handler/requirements.txt
@@ -1 +1 @@
-pgvector==0.3.6 
\ No newline at end of file
+pgvector==0.3.6
diff --git a/mindsdb/integrations/handlers/phoenix_handler/requirements.txt b/mindsdb/integrations/handlers/phoenix_handler/requirements.txt
index 7d8fd10bbc0..77441982eb4 100644
--- a/mindsdb/integrations/handlers/phoenix_handler/requirements.txt
+++ b/mindsdb/integrations/handlers/phoenix_handler/requirements.txt
@@ -1,2 +1,3 @@
 pyphoenix
 phoenixdb
+protobuf>=6.33.5 # not directly required, pinned by Snyk to avoid a vulnerability
diff --git a/mindsdb/integrations/handlers/postgres_handler/postgres_handler.py b/mindsdb/integrations/handlers/postgres_handler/postgres_handler.py
index 9e8330c19e9..a3456a8e95a 100644
--- a/mindsdb/integrations/handlers/postgres_handler/postgres_handler.py
+++ b/mindsdb/integrations/handlers/postgres_handler/postgres_handler.py
@@ -1,7 +1,7 @@
 import time
 import json
 import logging
-from typing import Optional, Any
+from typing import Optional, Any, Generator
 
 import pandas as pd
 from pandas import DataFrame
@@ -10,19 +10,25 @@
 from psycopg.postgres import TypeInfo, types as pg_types
 from psycopg.pq import ExecStatus
 
-from mindsdb_sql_parser import parse_sql
-from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb_sql_parser import parse_sql, Select
 from mindsdb_sql_parser.ast.base import ASTNode
 
-from mindsdb.integrations.libs.base import MetaDatabaseHandler
+import mindsdb.utilities.profiler as profiler
+from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb.utilities.types.column import Column
 from mindsdb.utilities import log
+from mindsdb.integrations.libs.base import MetaDatabaseHandler
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
     RESPONSE_TYPE,
+    TableResponse,
+    OkResponse,
+    ErrorResponse,
+    DataHandlerResponse,
 )
-import mindsdb.utilities.profiler as profiler
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
+from mindsdb.utilities.config import config as mindsdb_config
 
 logger = log.getLogger(__name__)
 
@@ -70,15 +76,14 @@ def _map_type(internal_type_name: str | None) -> MYSQL_DATA_TYPE:
     return fallback_type
 
 
-def _make_table_response(result: list[tuple[Any]], cursor: Cursor) -> Response:
-    """Build response from result and cursor.
+def _get_columns(cursor: Cursor) -> list[Column]:
+    """Get columns from cursor.
 
     Args:
-        result (list[tuple[Any]]): result of the query.
         cursor (psycopg.Cursor): cursor object.
 
     Returns:
-        Response: response object.
+        List of columns
     """
     description: list[PGColumn] = cursor.description
     mysql_types: list[MYSQL_DATA_TYPE] = []
@@ -108,11 +113,9 @@ def _make_table_response(result: list[tuple[Any]], cursor: Cursor) -> Response:
         mysql_type = _map_type(regtype)
         mysql_types.append(mysql_type)
 
-    # region cast int and bool to nullable types
-    serieses = []
-    for i, mysql_type in enumerate(mysql_types):
-        expected_dtype = None
-        if mysql_type in (
+    result = []
+    for i, column in enumerate(cursor.description):
+        if mysql_types[i] in (
             MYSQL_DATA_TYPE.SMALLINT,
             MYSQL_DATA_TYPE.INT,
             MYSQL_DATA_TYPE.MEDIUMINT,
@@ -120,13 +123,30 @@ def _make_table_response(result: list[tuple[Any]], cursor: Cursor) -> Response:
             MYSQL_DATA_TYPE.TINYINT,
         ):
             expected_dtype = "Int64"
-        elif mysql_type in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
+        elif mysql_types[i] in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
             expected_dtype = "boolean"
-        serieses.append(pd.Series([row[i] for row in result], dtype=expected_dtype, name=description[i].name))
-    df = pd.concat(serieses, axis=1, copy=False)
-    # endregion
+        else:
+            expected_dtype = None
+        result.append(
+            Column(name=column.name, type=mysql_types[i], original_type=column.type_display, dtype=expected_dtype)
+        )
+    return result
 
-    return Response(RESPONSE_TYPE.TABLE, data_frame=df, affected_rows=cursor.rowcount, mysql_types=mysql_types)
+
+def _make_df(result: list[tuple[Any]], columns: list[Column]) -> pd.DataFrame:
+    """Make pandas DataFrame from result and columns.
+
+    Args:
+        result (list[tuple[Any]]): result of the query.
+        columns (list[Column]): list of columns.
+
+    Returns:
+        pd.DataFrame: pandas DataFrame.
+    """
+    serieses = []
+    for i, column in enumerate(columns):
+        serieses.append(pd.Series([row[i] for row in result], dtype=column.dtype, name=column.name))
+    return pd.concat(serieses, axis=1, copy=False)
 
 
 class PostgresHandler(MetaDatabaseHandler):
@@ -135,6 +155,7 @@ class PostgresHandler(MetaDatabaseHandler):
     """
 
     name = "postgres"
+    stream_response = True
 
     @profiler.profile("init_pg_handler")
     def __init__(self, name=None, **kwargs):
@@ -282,19 +303,47 @@ def _cast_dtypes(self, df: DataFrame, description: list) -> DataFrame:
                         logger.error(f"Error casting column {col.name} to {types_map[pg_type_info.name]}: {e}")
         df.columns = columns
 
-    @profiler.profile()
-    def native_query(self, query: str, params=None, **kwargs) -> Response:
-        """
-        Executes a SQL query on the PostgreSQL database and returns the result.
+    def native_query(self, query: str, params=None, stream: bool = True, **kwargs) -> DataHandlerResponse:
+        """Executes a SQL query on the PostgreSQL database and returns the result.
+        NOTE: 'INSERT' (and may be some else) queries can not be executed on the server side,
+        but there are fallbackto client side execution.
 
         Args:
             query (str): The SQL query to be executed.
+            params (list): The parameters to be passed to the query.
+            stream (bool): Whether to stream the results of the query.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            Response: A response object containing the result of the query or an error message.
+            DataHandlerResponse: A response object containing the result of the query or an error message.
         """
-        need_to_close = not self.is_connected
+        if stream is False:
+            response = self._execute_client_side(query, params, **kwargs)
+        elif params is not None:
+            logger.info("Server side cursor does not support 'fetchmany', executing with client side cursor")
+            response = self._execute_client_side(query, params, **kwargs)
+        else:
+            generator = self._execute_server_side(query, **kwargs)
+            try:
+                response: TableResponse = next(generator)
+                response.data_generator = generator
+            except StopIteration as e:
+                response = e.value
+                if isinstance(response, DataHandlerResponse) is False:
+                    raise
+        return response
 
+    def _execute_client_side(self, query: str, params=None, **kwargs) -> TableResponse | OkResponse | ErrorResponse:
+        """Executes a SQL query on the PostgreSQL database and returns the result.
+
+        Args:
+            query (str): The SQL query to be executed.
+            params (list): The parameters to be passed to the query.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            TableResponse | OkResponse | ErrorResponse: A response object containing the result of the query or an error message.
+        """
         connection = self.connect()
         with connection.cursor() as cur:
             try:
@@ -303,66 +352,86 @@ def native_query(self, query: str, params=None, **kwargs) -> Response:
                 else:
                     cur.execute(query)
                 if cur.pgresult is None or ExecStatus(cur.pgresult.status) == ExecStatus.COMMAND_OK:
-                    response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
+                    response = OkResponse(affected_rows=cur.rowcount)
                 else:
                     result = cur.fetchall()
-                    response = _make_table_response(result, cur)
+                    columns: list[Column] = _get_columns(cur)
+                    response = TableResponse(
+                        affected_rows=cur.rowcount, columns=columns, data=_make_df(result, columns)
+                    )
                 connection.commit()
-            except (psycopg.ProgrammingError, psycopg.DataError) as e:
-                # These is 'expected' exceptions, they should not be treated as mindsdb's errors
-                # ProgrammingError: table not found or already exists, syntax error, etc
-                # DataError: division by zero, numeric value out of range, etc.
-                # https://www.psycopg.org/psycopg3/docs/api/errors.html
-                log_message = "Database query failed with error, likely due to invalid SQL query"
-                if logger.isEnabledFor(logging.DEBUG):
-                    log_message += f". Executed query:\n{query}"
-                logger.info(log_message)
-                response = Response(RESPONSE_TYPE.ERROR, error_code=0, error_message=str(e), is_expected_error=True)
-                connection.rollback()
             except Exception as e:
-                logger.error(f"Error running query:\n{query}\non {self.database}, {e}")
-                response = Response(RESPONSE_TYPE.ERROR, error_code=0, error_message=str(e))
-                connection.rollback()
-
-        if need_to_close:
-            self.disconnect()
+                response = self._handle_query_exception(e, query, connection)
 
         return response
 
-    def query_stream(self, query: ASTNode, fetch_size: int = 1000):
-        """
-        Executes a SQL query and stream results outside by batches
+    def _execute_server_side(
+        self, query: str, **kwargs
+    ) -> Generator[TableResponse | pd.DataFrame, None, OkResponse | ErrorResponse]:
+        """Execute a SQL query on the PostgreSQL database and return a generator of data frames.
 
-        :param query: An ASTNode representing the SQL query to be executed.
-        :param fetch_size: size of the batch
-        :return: generator with query results
-        """
-        query_str, params = self.renderer.get_exec_params(query, with_failback=True)
-
-        need_to_close = not self.is_connected
+        Args:
+            query (str): The SQL query to be executed.
+            params (list): The parameters to be passed to the query.
+            **kwargs: Additional keyword arguments.
 
+        Returns:
+            Generator[TableResponse | pd.DataFrame, None, OkResponse | ErrorResponse]: Generator of data frames.
+        """
         connection = self.connect()
-        with connection.cursor() as cur:
+        with connection.cursor(name=f"mindsdb_{id(self)}") as cursor:
             try:
-                if params is not None:
-                    cur.executemany(query_str, params)
-                else:
-                    cur.execute(query_str)
-
-                if cur.pgresult is not None and ExecStatus(cur.pgresult.status) != ExecStatus.COMMAND_OK:
-                    while True:
-                        result = cur.fetchmany(fetch_size)
-                        if not result:
-                            break
-                        df = DataFrame(result, columns=[x.name for x in cur.description])
-                        self._cast_dtypes(df, cur.description)
-                        yield df
+                try:
+                    cursor.execute(query)
+                except psycopg.errors.SyntaxError as e:
+                    # NOTE: INSERT queries cannot be executed server-side. When they fail, they produce a syntax error
+                    # that always starts with the text below, regardless of the INSERT query format.
+                    lower_e = str(e).lower()
+                    if not lower_e.startswith('syntax error at or near "insert"') and not lower_e.startswith(
+                        'syntax error at or near "drop"'
+                    ):
+                        raise
+                    connection.rollback()
+                    return self._execute_client_side(query=query)
+
+                if cursor.description is None:
+                    connection.commit()
+                    return OkResponse(affected_rows=cursor.rowcount)
+
+                columns: list[Column] = _get_columns(cursor)
+                yield TableResponse(affected_rows=cursor.rowcount, columns=columns)
+                while result := cursor.fetchmany(size=mindsdb_config["data_stream"]["fetch_size"]):
+                    yield _make_df(result, columns)
                 connection.commit()
-            finally:
-                connection.rollback()
+            except Exception as e:
+                return self._handle_query_exception(e, query, connection)
 
-        if need_to_close:
-            self.disconnect()
+    def _handle_query_exception(self, e: Exception, query: str, connection) -> ErrorResponse:
+        """Handle query execution errors with appropriate logging and rollback.
+
+        Args:
+            e: The exception that was raised
+            query: The SQL query that failed
+            connection: The database connection to rollback
+
+        Returns:
+            ErrorResponse with appropriate error details
+        """
+        if isinstance(e, (psycopg.ProgrammingError, psycopg.DataError)):
+            # These are 'expected' exceptions, they should not be treated as mindsdb's errors
+            # ProgrammingError: table not found or already exists, syntax error, etc
+            # DataError: division by zero, numeric value out of range, etc.
+            # https://www.psycopg.org/psycopg3/docs/api/errors.html
+            log_message = "Database query failed with error, likely due to invalid SQL query"
+            if logger.isEnabledFor(logging.DEBUG):
+                log_message += f". Executed query:\n{query}"
+            logger.info(log_message)
+            connection.rollback()
+            return ErrorResponse(error_code=0, error_message=str(e), is_expected_error=True)
+        else:
+            logger.error(f"Error running query:\n{query}\non {self.database}, {e}")
+            connection.rollback()
+            return ErrorResponse(error_code=0, error_message=str(e))
 
     def insert(self, table_name: str, df: pd.DataFrame) -> Response:
         need_to_close = not self.is_connected
@@ -401,7 +470,7 @@ def insert(self, table_name: str, df: pd.DataFrame) -> Response:
         return Response(RESPONSE_TYPE.OK, affected_rows=rowcount)
 
     @profiler.profile()
-    def query(self, query: ASTNode) -> Response:
+    def query(self, query: ASTNode) -> DataHandlerResponse:
         """
         Executes a SQL query represented by an ASTNode and retrieves the data.
 
@@ -409,11 +478,13 @@ def query(self, query: ASTNode) -> Response:
             query (ASTNode): An ASTNode representing the SQL query to be executed.
 
         Returns:
-            Response: The response from the `native_query` method, containing the result of the SQL query execution.
+            DataHandlerResponse: The response from the `native_query` method,
+                                 containing the result of the SQL query execution.
         """
         query_str, params = self.renderer.get_exec_params(query, with_failback=True)
         logger.debug(f"Executing SQL query: {query_str}")
-        return self.native_query(query_str, params)
+        support_stream = isinstance(query, Select)
+        return self.native_query(query_str, params, stream=support_stream)
 
     def get_tables(self, all: bool = False) -> Response:
         """
@@ -545,7 +616,7 @@ def subscribe(self, stop_event, callback, table_name, columns=None, **kwargs):
         def process_event(event):
             try:
                 row = json.loads(event.payload)
-            except json.JSONDecoder:
+            except json.JSONDecodeError:
                 return
 
             # check column in input data
@@ -687,31 +758,33 @@ def meta_get_column_statistics(self, table_names: Optional[list] = None) -> Resp
 
         result = self.native_query(query)
 
-        if result.type == RESPONSE_TYPE.TABLE and result.data_frame is not None:
-            df = result.data_frame
-
-            # Extract min/max from histogram bounds
-            def extract_min_max(histogram_str):
-                if histogram_str and str(histogram_str) != "nan":
-                    clean = str(histogram_str).strip("{}")
-                    if clean:
-                        values = clean.split(",")
-                        min_val = values[0].strip(" \"'") if values else None
-                        max_val = values[-1].strip(" \"'") if values else None
-                        return min_val, max_val
-                return None, None
-
-            min_max_values = df["histogram_bounds"].apply(extract_min_max)
-            df["MINIMUM_VALUE"] = min_max_values.apply(lambda x: x[0])
-            df["MAXIMUM_VALUE"] = min_max_values.apply(lambda x: x[1])
-
-            # Convert most_common_values and most_common_freqs to arrays.
-            df["MOST_COMMON_VALUES"] = df["most_common_values"].apply(
-                lambda x: x.strip("{}").split(",") if isinstance(x, str) else []
-            )
-            df["MOST_COMMON_FREQUENCIES"] = df["most_common_frequencies"].apply(
-                lambda x: x.strip("{}").split(",") if isinstance(x, str) else []
-            )
+        if result.type != RESPONSE_TYPE.TABLE or result.data_frame is None:
+            return result
+
+        df = result.data_frame
+
+        # Extract min/max from histogram bounds
+        def extract_min_max(histogram_str):
+            if histogram_str and str(histogram_str) != "nan":
+                clean = str(histogram_str).strip("{}")
+                if clean:
+                    values = clean.split(",")
+                    min_val = values[0].strip(" \"'") if values else None
+                    max_val = values[-1].strip(" \"'") if values else None
+                    return min_val, max_val
+            return None, None
+
+        min_max_values = df["histogram_bounds"].apply(extract_min_max)
+        df["MINIMUM_VALUE"] = min_max_values.apply(lambda x: x[0])
+        df["MAXIMUM_VALUE"] = min_max_values.apply(lambda x: x[1])
+
+        # Convert most_common_values and most_common_freqs to arrays.
+        df["MOST_COMMON_VALUES"] = df["most_common_values"].apply(
+            lambda x: x.strip("{}").split(",") if isinstance(x, str) else []
+        )
+        df["MOST_COMMON_FREQUENCIES"] = df["most_common_frequencies"].apply(
+            lambda x: x.strip("{}").split(",") if isinstance(x, str) else []
+        )
 
         result.data_frame = df.drop(columns=["histogram_bounds", "most_common_values", "most_common_frequencies"])
 
diff --git a/mindsdb/integrations/handlers/raindrop_handler/README.md b/mindsdb/integrations/handlers/raindrop_handler/README.md
new file mode 100644
index 00000000000..835d24fd0d7
--- /dev/null
+++ b/mindsdb/integrations/handlers/raindrop_handler/README.md
@@ -0,0 +1,651 @@
+# Raindrop.io Handler
+
+Raindrop.io handler for MindsDB provides interfaces to connect to Raindrop.io via APIs and pull data into MindsDB. This handler also supports creating, updating, and deleting bookmarks and collections.
+
+---
+
+## Table of Contents
+
+- [Raindrop.io Handler](#raindropio-handler)
+  - [Table of Contents](#table-of-contents)
+  - [About Raindrop.io](#about-raindropio)
+  - [Raindrop.io Handler Implementation](#raindropio-handler-implementation)
+  - [Raindrop.io Handler Initialization](#raindropio-handler-initialization)
+  - [How to Get Your Raindrop.io API Key](#how-to-get-your-raindropio-api-key)
+  - [Implemented Features](#implemented-features)
+  - [Tables](#tables)
+    - [Raindrops (Bookmarks)](#raindrops-bookmarks)
+    - [Collections](#collections)
+  - [Example Usage](#example-usage)
+    - [Connecting to Raindrop.io](#connecting-to-raindropio)
+    - [Selecting Bookmarks](#selecting-bookmarks)
+    - [Creating Bookmarks](#creating-bookmarks)
+    - [Updating Bookmarks](#updating-bookmarks)
+    - [Deleting Bookmarks](#deleting-bookmarks)
+    - [Working with Collections](#working-with-collections)
+
+---
+
+## About Raindrop.io
+
+Raindrop.io is a bookmarking service that allows users to organize, save, and manage web bookmarks. It provides a clean interface for saving links, organizing them into collections, adding tags, notes, and highlights. Raindrop.io offers both personal and collaborative features for managing bookmarks across teams.
+
+Website: https://raindrop.io
+
+## Raindrop.io Handler Implementation
+
+This handler was implemented using the [Raindrop.io REST API v1](https://developer.raindrop.io/). The handler provides comprehensive support for managing bookmarks (called "raindrops" in the API) and collections through SQL-like operations.
+
+## Raindrop.io Handler Initialization
+
+The Raindrop.io handler is initialized with the following parameter:
+
+- `api_key`: a required Raindrop.io API access token
+
+## How to Get Your Raindrop.io API Key
+
+1. Sign up for an account on [Raindrop.io](https://raindrop.io)
+2. Go to [App Management Console](https://app.raindrop.io/settings/integrations)
+3. Create a new application or use an existing one
+4. For testing purposes, you can copy the "Test token" from your application settings
+5. For production use, implement OAuth2 flow as described in the [API documentation](https://developer.raindrop.io/v1/authentication/token)
+
+## Implemented Features
+
+### Raindrops (Bookmarks) Table
+- [x] Support SELECT with advanced filtering and pagination
+  - [x] Filter by collection_id, search terms, title
+  - [x] Support for sorting by created, lastUpdate, sort, title
+  - [x] Support for LIMIT and pagination
+  - [x] Support for specific bookmark IDs
+  - [x] **NEW**: Advanced WHERE clause operators (>, <, >=, <=, BETWEEN, IN, LIKE)
+  - [x] **NEW**: Date range filtering with automatic datetime conversion
+  - [x] **NEW**: Complex condition combinations with AND/OR logic
+  - [x] **NEW**: Local filtering for non-API supported conditions
+- [x] Support INSERT for creating new bookmarks
+  - [x] Single bookmark creation
+  - [x] Bulk bookmark creation
+- [x] Support UPDATE for modifying existing bookmarks
+  - [x] Single bookmark updates
+  - [x] Bulk bookmark updates with WHERE conditions
+- [x] Support DELETE for removing bookmarks
+  - [x] Single bookmark deletion
+  - [x] Bulk bookmark deletion with WHERE conditions
+
+### Collections Table
+- [x] Support SELECT with filtering and pagination
+  - [x] Support for all collection fields
+  - [x] Support for LIMIT and ORDER BY
+- [x] Support INSERT for creating new collections
+- [x] Support UPDATE for modifying existing collections
+- [x] Support DELETE for removing collections
+  - [x] Single collection deletion
+  - [x] Bulk collection deletion
+
+### Tags Table
+- [x] Support SELECT for querying tag statistics
+  - [x] Tag usage counts and metadata
+  - [x] Support for filtering and sorting
+  - [x] Support for LIMIT and pagination
+- [ ] Support INSERT for creating tags (not supported by API)
+- [ ] Support UPDATE for modifying tags (not supported by API)
+- [ ] Support DELETE for removing tags (not supported by API)
+
+### Parse Table
+- [x] Support SELECT for URL metadata extraction
+  - [x] Extract title, description, and other metadata from URLs
+  - [x] Support for single URL parsing
+  - [x] Support for multiple URL parsing with IN operator
+  - [x] Error handling for invalid URLs
+- [ ] Support INSERT for creating parsed URLs (read-only operation)
+- [ ] Support UPDATE for modifying parsed URLs (read-only operation)
+- [ ] Support DELETE for removing parsed URLs (read-only operation)
+
+### Bulk Operations Table
+- [x] Support UPDATE for bulk collection moves
+  - [x] Move bookmarks by source collection ID
+  - [x] Move specific bookmarks by ID
+  - [x] Move bookmarks by search criteria
+  - [x] Batch processing with error handling
+- [ ] Support SELECT for bulk operation status (not queryable)
+- [ ] Support INSERT for bulk operations (not applicable)
+- [ ] Support DELETE for bulk operations (use raindrops table)
+
+## Tables
+
+### Tags
+
+The `tags` table provides access to tag management and statistics from Raindrop.io.
+
+Available columns:
+- `_id` (str): Unique tag identifier
+- `label` (str): Tag name/label
+- `count` (int): Number of bookmarks using this tag
+- `created` (datetime): Tag creation timestamp
+- `lastUpdate` (datetime): Last update timestamp
+
+**Note**: Direct tag creation, updates, and deletion are not supported by the Raindrop.io API. Tags are created automatically when bookmarks are tagged, and are removed automatically when no bookmarks use them.
+
+#### Selecting Tags
+
+```sql
+-- Get all tags
+SELECT * FROM raindrop_db.tags;
+
+-- Get tags sorted by usage count
+SELECT label, count FROM raindrop_db.tags
+ORDER BY count DESC;
+
+-- Get tags with specific usage count
+SELECT label, count FROM raindrop_db.tags
+WHERE count > 5
+ORDER BY count DESC;
+
+-- Get most popular tags (top 10)
+SELECT label, count FROM raindrop_db.tags
+ORDER BY count DESC
+LIMIT 10;
+
+-- Get recently created tags
+SELECT label, created FROM raindrop_db.tags
+WHERE created > '2024-01-01'
+ORDER BY created DESC;
+```
+
+### Parse
+
+The `parse` table provides URL metadata extraction functionality using Raindrop.io's parsing service.
+
+Available columns:
+- `parsed_url` (str): The original URL that was parsed
+- `title` (str): Extracted title from the URL
+- `excerpt` (str): Brief description or excerpt from the URL
+- `domain` (str): Domain name of the URL
+- `type` (str): Content type (article, image, video, etc.)
+- `cover` (str): Cover image URL if available
+- `media` (list): Media attachments found on the page
+- `lastUpdate` (datetime): Last update timestamp for the parsed content
+- `error` (str): Error message if parsing failed
+
+**Note**: The parse table is read-only and used for extracting metadata from URLs before creating bookmarks.
+
+#### Parsing URLs
+
+```sql
+-- Parse a single URL to extract metadata
+SELECT parsed_url, title, excerpt, domain, type, cover
+FROM raindrop_db.parse
+WHERE url = 'https://example.com/article';
+
+-- Parse multiple URLs at once
+SELECT parsed_url, title, excerpt, domain
+FROM raindrop_db.parse
+WHERE url IN ('https://example1.com', 'https://example2.com', 'https://example3.com');
+
+-- Get detailed metadata including media
+SELECT parsed_url, title, excerpt, media, lastUpdate
+FROM raindrop_db.parse
+WHERE url = 'https://news.example.com/article';
+
+-- Parse URLs with error handling
+SELECT parsed_url, title, excerpt, error
+FROM raindrop_db.parse
+WHERE url IN ('https://valid-url.com', 'https://invalid-url.com');
+
+-- Use parsed data to create bookmarks (combined query)
+INSERT INTO raindrop_db.raindrops (link, title, excerpt, collection_id)
+SELECT parsed_url, title, excerpt, 123
+FROM raindrop_db.parse
+WHERE url = 'https://example.com/article-to-bookmark';
+```
+
+### Raindrops (Bookmarks)
+
+Available columns:
+- `_id` (int): Unique bookmark ID
+- `link` (str): The URL of the bookmark
+- `title` (str): Title of the bookmark
+- `excerpt` (str): Brief description or excerpt
+- `note` (str): Personal notes
+- `type` (str): Type of bookmark (link, article, image, video, etc.)
+- `cover` (str): Cover image URL
+- `tags` (str): Comma-separated tags
+- `important` (bool): Whether the bookmark is marked as important
+- `reminder` (datetime): Reminder date/time
+- `removed` (bool): Whether the bookmark is removed/trashed
+- `created` (datetime): Creation timestamp
+- `lastUpdate` (datetime): Last update timestamp
+- `domain` (str): Domain of the bookmarked URL
+- `collection.id` (int): ID of the collection containing this bookmark
+- `collection.title` (str): Title of the collection
+- `user.id` (int): ID of the user who owns this bookmark
+- `broken` (bool): Whether the link is broken
+- `cache` (str): Whether a cached copy exists
+- `file.name` (str): File name (for file bookmarks)
+- `file.size` (int): File size (for file bookmarks)
+- `file.type` (str): File type (for file bookmarks)
+
+### Collections
+
+Available columns:
+- `_id` (int): Unique collection ID
+- `title` (str): Collection title
+- `description` (str): Collection description
+- `color` (str): Collection color (hex code)
+- `view` (str): View type (list, grid, etc.)
+- `public` (bool): Whether the collection is public
+- `sort` (int): Sort order
+- `count` (int): Number of bookmarks in collection
+- `created` (datetime): Creation timestamp
+- `lastUpdate` (datetime): Last update timestamp
+- `expanded` (bool): Whether the collection is expanded in UI
+- `parent.id` (int): Parent collection ID (for nested collections)
+- `user.id` (int): ID of the user who owns this collection
+- `cover` (str): Cover image URL
+- `access.level` (int): Access level
+- `access.draggable` (bool): Whether the collection can be dragged
+
+## Example Usage
+
+### Connecting to Raindrop.io
+
+```sql
+CREATE DATABASE raindrop_db
+WITH ENGINE = 'raindrop',
+PARAMETERS = {
+    "api_key": "your_raindrop_api_token_here"
+};
+```
+
+### Selecting Bookmarks
+
+```sql
+-- Get all bookmarks
+SELECT * FROM raindrop_db.raindrops;
+
+-- Get bookmarks from a specific collection
+SELECT * FROM raindrop_db.raindrops
+WHERE collection_id = 12345;
+
+-- Search for bookmarks (enhanced search capabilities)
+SELECT title, link, tags FROM raindrop_db.raindrops
+WHERE search = 'programming'
+LIMIT 10;
+
+-- Advanced search with multiple field searches (automatically optimized)
+SELECT * FROM raindrop_db.raindrops
+WHERE title = 'Python Tutorial' AND excerpt = 'Learn Python';
+
+-- Optimized LIKE patterns (automatically converted to API search)
+SELECT * FROM raindrop_db.raindrops
+WHERE title LIKE '%python%' OR excerpt LIKE '%tutorial%';
+
+-- Get bookmarks with specific tags
+SELECT * FROM raindrop_db.raindrops
+WHERE title LIKE '%python%'
+ORDER BY created DESC;
+
+-- Get important bookmarks
+SELECT title, link, created FROM raindrop_db.raindrops
+WHERE important = true;
+
+-- Advanced filtering with comparison operators
+SELECT * FROM raindrop_db.raindrops
+WHERE created > '2024-01-01'
+ORDER BY created DESC;
+
+SELECT title, link FROM raindrop_db.raindrops
+WHERE sort <= 50
+  AND important = true;
+
+-- Date range filtering
+SELECT * FROM raindrop_db.raindrops
+WHERE created BETWEEN '2024-01-01' AND '2024-12-31';
+
+-- IN operator for multiple values
+SELECT * FROM raindrop_db.raindrops
+WHERE _id IN (123, 456, 789);
+
+SELECT * FROM raindrop_db.raindrops
+WHERE collection_id IN (0, 1, 2);
+
+-- LIKE operator for pattern matching
+SELECT * FROM raindrop_db.raindrops
+WHERE title LIKE '%python%'
+   OR excerpt LIKE '%tutorial%';
+
+-- Complex conditions with multiple filters
+SELECT title, link, tags, created FROM raindrop_db.raindrops
+WHERE created >= '2024-06-01'
+  AND important = true
+  AND (title LIKE '%project%' OR tags LIKE '%work%')
+ORDER BY created DESC
+LIMIT 20;
+
+-- Advanced filtering with multiple AND conditions
+SELECT * FROM raindrop_db.raindrops
+WHERE collection_id = 123
+  AND created BETWEEN '2024-01-01' AND '2024-12-31'
+  AND important = true
+  AND sort > 10;
+
+-- Complex queries with mixed operators
+SELECT title, link, excerpt FROM raindrop_db.raindrops
+WHERE (title LIKE '%tutorial%' OR excerpt LIKE '%guide%')
+  AND created >= '2024-06-01'
+  AND _id NOT IN (123, 456, 789)
+ORDER BY sort DESC;
+
+-- Query untagged bookmarks
+SELECT * FROM raindrop_db.raindrops
+WHERE tags = "";
+
+-- Get specific columns for untagged bookmarks
+SELECT _id, title, link, excerpt FROM raindrop_db.raindrops
+WHERE tags = "";
+
+-- Count untagged bookmarks
+SELECT COUNT(*) FROM raindrop_db.raindrops
+WHERE tags = "";
+
+-- Get untagged bookmarks from a specific collection
+SELECT * FROM raindrop_db.raindrops
+WHERE collection_id = 0 AND tags = "";
+
+-- Get untagged bookmarks sorted by creation date
+SELECT title, link, created FROM raindrop_db.raindrops
+WHERE tags = ""
+ORDER BY created DESC;
+
+-- Get untagged bookmarks with additional filters
+SELECT * FROM raindrop_db.raindrops
+WHERE tags = "" AND important = true;
+
+-- Get recent untagged bookmarks
+SELECT title, link, created FROM raindrop_db.raindrops
+WHERE tags = "" AND created > '2024-01-01'
+ORDER BY created DESC;
+
+-- Query broken links
+SELECT * FROM raindrop_db.raindrops
+WHERE broken = true;
+
+-- Count broken links (manual counting approach)
+SELECT _id FROM raindrop_db.raindrops
+WHERE broken = true;
+-- Note: Use application-side counting for total count
+
+-- Get broken links with details
+SELECT _id, title, link, domain, lastUpdate FROM raindrop_db.raindrops
+WHERE broken = true;
+
+-- Get broken links from a specific collection
+SELECT * FROM raindrop_db.raindrops
+WHERE collection_id = 0 AND broken = true;
+
+-- Get broken links sorted by last update
+SELECT title, link, lastUpdate FROM raindrop_db.raindrops
+WHERE broken = true
+ORDER BY lastUpdate DESC;
+
+-- Get broken links that are also important
+SELECT * FROM raindrop_db.raindrops
+WHERE broken = true AND important = true;
+```
+
+### Creating Bookmarks
+
+```sql
+-- Create a single bookmark
+INSERT INTO raindrop_db.raindrops (link, title, note, tags, collection_id) 
+VALUES (
+    'https://example.com', 
+    'Example Website', 
+    'This is a great example', 
+    'example,website,test',
+    12345
+);
+
+-- Create multiple bookmarks
+INSERT INTO raindrop_db.raindrops (link, title, collection_id) 
+VALUES 
+    ('https://github.com', 'GitHub', 0),
+    ('https://stackoverflow.com', 'Stack Overflow', 0);
+```
+
+### Updating Bookmarks
+
+```sql
+-- Update a specific bookmark
+UPDATE raindrop_db.raindrops 
+SET title = 'New Title', note = 'Updated note', important = true
+WHERE _id = 123456;
+
+-- Update multiple bookmarks
+UPDATE raindrop_db.raindrops 
+SET collection_id = 54321 
+WHERE tags LIKE '%oldtag%';
+
+-- Mark bookmarks as important
+UPDATE raindrop_db.raindrops 
+SET important = true 
+WHERE title LIKE '%important%';
+```
+
+### Deleting Bookmarks
+
+```sql
+-- Delete a specific bookmark
+DELETE FROM raindrop_db.raindrops 
+WHERE _id = 123456;
+
+-- Delete bookmarks by search criteria
+DELETE FROM raindrop_db.raindrops 
+WHERE tags LIKE '%obsolete%';
+
+-- Delete old bookmarks
+DELETE FROM raindrop_db.raindrops 
+WHERE created < '2023-01-01';
+```
+
+### Working with Collections
+
+```sql
+-- Get all collections
+SELECT * FROM raindrop_db.collections;
+
+-- Create a new collection
+INSERT INTO raindrop_db.collections (title, description, color, view) 
+VALUES ('Programming', 'Programming related bookmarks', '#FF0000', 'list');
+
+-- Update a collection
+UPDATE raindrop_db.collections 
+SET title = 'Web Development', color = '#00FF00' 
+WHERE _id = 12345;
+
+-- Delete a collection
+DELETE FROM raindrop_db.collections 
+WHERE _id = 12345;
+
+-- Get collections with bookmark counts
+SELECT title, count, lastUpdate FROM raindrop_db.collections 
+ORDER BY count DESC;
+```
+
+### Advanced Queries
+
+```sql
+-- Get bookmarks with collection information
+SELECT r.title, r.link, r.tags, c.title as collection_name
+FROM raindrop_db.raindrops r
+JOIN raindrop_db.collections c ON r.collection_id = c._id
+WHERE r.important = true;
+
+-- Get recent bookmarks from multiple collections
+SELECT title, link, created, collection_id
+FROM raindrop_db.raindrops 
+WHERE collection_id IN (123, 456, 789)
+AND created > '2024-01-01'
+ORDER BY created DESC 
+LIMIT 20;
+
+-- Search across title and notes
+SELECT title, link, note 
+FROM raindrop_db.raindrops 
+WHERE title LIKE '%python%' OR note LIKE '%python%'
+ORDER BY lastUpdate DESC;
+```
+
+### Bulk Operations
+
+```sql
+-- Move all bookmarks from one collection to another
+UPDATE raindrop_db.bulk_operations
+SET collection_id = 456
+WHERE source_collection_id = 123;
+
+-- Move specific bookmarks to a collection
+UPDATE raindrop_db.bulk_operations
+SET collection_id = 789
+WHERE _id IN (1, 2, 3, 4, 5);
+
+-- Move bookmarks matching search criteria
+UPDATE raindrop_db.bulk_operations
+SET collection_id = 999
+WHERE search = 'python tutorial';
+
+-- Combine with other operations - move then update
+UPDATE raindrop_db.bulk_operations
+SET collection_id = 456
+WHERE source_collection_id = 123;
+
+UPDATE raindrop_db.raindrops
+SET important = true
+WHERE collection_id = 456 AND created > '2024-01-01';
+```
+
+## API Rate Limits
+
+The Raindrop.io API has the following rate limits:
+- 120 requests per minute for authenticated users
+- The handler automatically handles pagination (API returns max 50 items per request)
+- Bulk operations are used when possible to minimize API calls
+
+### Rate Limiting Features
+
+The handler includes intelligent rate limiting to prevent hitting API quotas:
+
+- **Automatic Throttling**: Requests are automatically delayed to stay within 120 requests/minute limit
+- **Smart Pagination**: Page sizes are optimized based on LIMIT clauses (e.g., LIMIT 5 uses smaller pages)
+- **Request Tracking**: The handler tracks request times and adds delays when approaching limits
+- **Graceful Degradation**: Continues working even with rate limit errors
+
+**Example**: A `SELECT * FROM raindrop_db.raindrops LIMIT 5` query will use smaller page sizes and make fewer requests compared to larger queries.
+
+## Error Handling
+
+The handler includes comprehensive error handling:
+- Connection validation on initialization
+- Graceful fallback from bulk operations to individual operations when needed
+- Proper error logging for debugging
+- Handles API rate limiting and network errors
+
+## Recent Improvements
+
+### Version 0.0.1 Improvements
+- **Robust Data Normalization**: Enhanced column normalization to handle missing nested fields gracefully
+- **Defensive Column Checks**: Added checks to ensure all expected columns exist before query execution
+- **Empty Data Handling**: Improved handling of empty API responses with proper column structure
+- **Error Resilience**: Added try-catch blocks around data processing operations to prevent crashes
+- **Logging Integration**: Replaced print statements with proper logging for better integration with MindsDB
+- **Rate Limiting**: Implemented intelligent rate limiting to prevent API quota exhaustion (120 requests/minute)
+- **Optimized Pagination**: Smart page sizing based on LIMIT clauses to minimize API calls
+- **Request Throttling**: Automatic delays between requests to stay within API limits
+
+### Version 0.0.2 Improvements
+- **Advanced WHERE Clause Operators**: Added support for >, <, >=, <=, BETWEEN, IN, and LIKE operators
+- **Date Range Filtering**: Automatic datetime conversion and comparison for date-based filtering
+- **Complex Condition Combinations**: Support for multiple AND/OR conditions in WHERE clauses
+- **Advanced Filtering API**: New `/filters` endpoint integration for complex queries
+- **Intelligent Query Routing**: Automatic selection between standard and advanced filtering endpoints
+- **Fallback Mechanisms**: Graceful degradation when advanced endpoints are unavailable
+- **Enhanced Error Handling**: Comprehensive error handling for API failures and edge cases
+- **Local Filtering Engine**: Intelligent routing between API-supported and locally-processed filters
+- **Enhanced Query Performance**: Optimized data fetching based on filter types and complexity
+- **Comprehensive Test Coverage**: 49 unit tests covering all new filtering capabilities
+
+### Version 0.0.3 Improvements
+- **Tags Table**: New `tags` table for tag management and statistics
+- **Tag Statistics**: Access to tag usage counts and metadata
+- **Tag Filtering**: Support for filtering and sorting tags by usage and creation date
+- **API Integration**: Full integration with Raindrop.io `/tags` endpoint
+- **Read-Only Operations**: Proper handling of API limitations for tag CRUD operations
+- **Enhanced Documentation**: Comprehensive examples for tag queries
+- **Test Coverage**: Additional unit tests for tags table functionality
+
+### Version 0.0.4 Improvements
+- **Parse Table**: New `parse` table for URL metadata extraction
+- **URL Metadata Extraction**: Extract title, description, domain, and media from URLs
+- **Batch URL Parsing**: Support for parsing multiple URLs with IN operator
+- **Error Handling**: Graceful error handling for invalid or unreachable URLs
+- **API Integration**: Full integration with Raindrop.io `/parse` endpoint
+- **Read-Only Operations**: Parse table designed as read-only for metadata extraction
+- **Enhanced Documentation**: Comprehensive examples for URL parsing queries
+- **Test Coverage**: Complete unit test suite for parse table functionality
+
+### Version 0.0.5 Improvements
+- **Bulk Operations Table**: New `bulk_operations` table for bulk collection moves
+- **Bulk Collection Moves**: Move multiple bookmarks between collections efficiently
+- **Flexible Move Criteria**: Support for moving by collection ID, bookmark IDs, or search terms
+- **API Integration**: Full integration with Raindrop.io bulk update endpoints
+- **Error Handling**: Comprehensive error handling for bulk operations
+- **SQL Interface**: User-friendly SQL interface for bulk operations
+- **Enhanced Documentation**: Comprehensive examples for bulk move operations
+- **Test Coverage**: Complete unit test suite for bulk operations functionality
+
+### Version 0.0.6 Improvements
+- **Enhanced Full-Text Search**: Improved search capabilities with automatic optimization
+- **Multi-Field Search**: Support for searching across title, excerpt, note, and tags fields
+- **Smart LIKE Optimization**: Automatic conversion of simple LIKE patterns to API search
+- **Field-Specific Search**: Convert field-specific searches to optimized API queries
+- **Search Query Combination**: Intelligent combination of multiple search conditions
+- **Preserved User Intent**: Respect explicit search queries while optimizing others
+- **Performance Optimization**: Reduced local filtering by leveraging API search capabilities
+- **Backward Compatibility**: All existing search functionality remains unchanged
+- **Comprehensive Test Coverage**: 10 additional tests for search optimization features
+
+### Version 0.0.7 Improvements
+- **Full API Compatibility**: Comprehensive evaluation and fixes for official Raindrop API compatibility
+- **Fixed Endpoint URLs**: Corrected `/collections/childrens` to `/collections/children` to match API spec
+- **Corrected Sort Parameters**: Fixed sort parameter format from `{field},-{direction}` to `field`/`-field`
+- **Parameter Name Compliance**: Ensured all parameter names match official API specification (`perpage`, etc.)
+- **Enhanced Security**: Updated allowed endpoints list with correct API paths
+- **Rate Limiting Validation**: Verified rate limiting implementation matches API limits (120 requests/minute)
+- **Authentication Compliance**: Confirmed Bearer token authentication format matches API requirements
+- **Response Format Compatibility**: Verified response structure expectations match API responses
+- **Error Handling Compatibility**: Ensured error handling matches API error response formats
+- **Comprehensive Compatibility Tests**: 9 additional tests covering all aspects of API compatibility
+
+### Version 0.0.8 Improvements
+- **Fixed Collections Query Error**: Resolved 404 error when querying collections due to invalid `/collections/children` endpoint
+- **Simplified Collections API**: Removed separate child collections call, using single `/collections` endpoint for all collections
+- **Updated Collections Logic**: Modified `get_collections()` to return both root and nested collections from single API call
+- **Enhanced Error Handling**: Improved error handling for collections queries
+- **Updated Test Suite**: Fixed existing tests to work with new collections API approach
+- **Collections Endpoint Tests**: Added comprehensive tests for collections endpoint fix and table integration
+- **API Compatibility Enhancement**: Further improved compatibility by fixing collections endpoint issues
+
+### Dependency Management
+- Removed duplicate `requests` dependency from handler-specific requirements.txt
+- All dependencies are now properly managed through the main requirements.txt file
+
+## Notes
+
+- The `raindrops` table has an alias `bookmarks` for convenience
+- All date fields are automatically converted to pandas datetime objects
+- Tags are stored as comma-separated strings for easier querying
+- The handler supports both single and bulk operations for better performance
+- Collection ID 0 represents "All bookmarks" (unsorted)
+- Collection ID -1 represents "Unsorted" bookmarks
+- Collection ID -99 represents "Trash"
+- The `requests` dependency is already declared in the main requirements.txt file, so it's not included in this handler's requirements.txt to avoid duplication
diff --git a/mindsdb/integrations/handlers/raindrop_handler/__about__.py b/mindsdb/integrations/handlers/raindrop_handler/__about__.py
new file mode 100644
index 00000000000..681a687cf8d
--- /dev/null
+++ b/mindsdb/integrations/handlers/raindrop_handler/__about__.py
@@ -0,0 +1,9 @@
+__title__ = "MindsDB Raindrop.io handler"
+__package_name__ = "mindsdb_raindrop_handler"
+__version__ = "0.0.8"
+__description__ = "MindsDB handler for Raindrop.io"
+__author__ = "Lukas Wolfsteiner <lukas@wolfsteiner.media>"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2025 - MindsDB"
diff --git a/mindsdb/integrations/handlers/raindrop_handler/__init__.py b/mindsdb/integrations/handlers/raindrop_handler/__init__.py
new file mode 100644
index 00000000000..ff1d4d2b171
--- /dev/null
+++ b/mindsdb/integrations/handlers/raindrop_handler/__init__.py
@@ -0,0 +1,30 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+from .connection_args import connection_args, connection_args_example
+
+try:
+    from .raindrop_handler import RaindropHandler as Handler
+
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Raindrop.io"
+name = "raindrop"
+type = HANDLER_TYPE.DATA
+icon_path = "icon.svg"
+
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "import_error",
+    "icon_path",
+    "connection_args_example",
+    "connection_args",
+]
diff --git a/mindsdb/integrations/handlers/raindrop_handler/connection_args.py b/mindsdb/integrations/handlers/raindrop_handler/connection_args.py
new file mode 100644
index 00000000000..82e7fae2f64
--- /dev/null
+++ b/mindsdb/integrations/handlers/raindrop_handler/connection_args.py
@@ -0,0 +1,16 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+connection_args = OrderedDict(
+    api_key={
+        "type": ARG_TYPE.PWD,
+        "description": "Raindrop.io API access token. You can get this from https://app.raindrop.io/settings/integrations",
+        "required": True,
+        "label": "API Key",
+        "secret": True,
+    },
+)
+
+connection_args_example = OrderedDict(api_key="aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeee")
diff --git a/mindsdb/integrations/handlers/raindrop_handler/icon.svg b/mindsdb/integrations/handlers/raindrop_handler/icon.svg
new file mode 100644
index 00000000000..67ed32e1bfa
--- /dev/null
+++ b/mindsdb/integrations/handlers/raindrop_handler/icon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 48 48"><defs/><defs><path id="a" d="M12 0a12 12 0 0112 12v12H12a12 12 0 110-24z"/><path id="c" d="M0 24V11.7A12 12 0 1112 24H0z"/></defs><g fill="none" fill-rule="evenodd"><path fill="#1988E0" d="M35.3 9.7a16 16 0 01-.6 23.2L24 43 13.3 33l-.6-.7A16 16 0 1135.3 9.7z"/><g transform="translate(0 19)"><mask id="b" fill="#fff"><use xlink:href="#a"/></mask><use fill="#2CD4ED" xlink:href="#a"/><path fill="#0DB4E2" d="M35.3-9.3a16 16 0 01-.6 23.2L24 24 13.3 14l-.6-.7A16 16 0 1135.3-9.3z" mask="url(#b)"/></g><g transform="translate(24 19)"><mask id="d" fill="#fff"><use xlink:href="#c"/></mask><use fill="#3169FF" xlink:href="#c"/><path fill="#3153FF" d="M11.3-9.3a16 16 0 01-.6 23.2L0 24l-10.7-10-.6-.7A16 16 0 1111.3-9.3z" mask="url(#d)"/></g></g></svg>
\ No newline at end of file
diff --git a/mindsdb/integrations/handlers/raindrop_handler/raindrop_handler.py b/mindsdb/integrations/handlers/raindrop_handler/raindrop_handler.py
new file mode 100644
index 00000000000..e2850a9f6b0
--- /dev/null
+++ b/mindsdb/integrations/handlers/raindrop_handler/raindrop_handler.py
@@ -0,0 +1,379 @@
+import requests
+import time
+from typing import Dict, Any, List
+
+from mindsdb_sql_parser import parse_sql
+
+from mindsdb.integrations.handlers.raindrop_handler.raindrop_tables import (
+    RaindropsTable,
+    CollectionsTable,
+    TagsTable,
+    ParseTable,
+    BulkOperationsTable,
+)
+from mindsdb.integrations.libs.api_handler import APIHandler
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+)
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+class RaindropHandler(APIHandler):
+    """The Raindrop.io handler implementation"""
+
+    def __init__(self, name: str, **kwargs):
+        """Initialize the Raindrop.io handler.
+
+        Parameters
+        ----------
+        name : str
+            name of a handler instance
+        """
+        super().__init__(name)
+
+        connection_data = kwargs.get("connection_data", {})
+        self.connection_data = connection_data
+        self.kwargs = kwargs
+
+        self.connection = None
+        self.is_connected = False
+
+        # Register tables
+        self._register_table("raindrops", RaindropsTable(self))
+        self._register_table("bookmarks", RaindropsTable(self))  # Alias for raindrops
+        self._register_table("collections", CollectionsTable(self))
+        self._register_table("tags", TagsTable(self))
+        self._register_table("parse", ParseTable(self))
+        self._register_table("bulk_operations", BulkOperationsTable(self))
+
+    def connect(self) -> StatusResponse:
+        """Set up the connection required by the handler.
+
+        Returns
+        -------
+        StatusResponse
+            connection object
+        """
+        if self.is_connected is True:
+            return self.connection
+
+        api_key = self.connection_data.get("api_key")
+        if not api_key:
+            raise ValueError("API key is required for Raindrop.io connection")
+
+        self.connection = RaindropAPIClient(api_key)
+        self.is_connected = True
+
+        return self.connection
+
+    def check_connection(self) -> StatusResponse:
+        """Check connection to the handler.
+
+        Returns
+        -------
+        StatusResponse
+            Status confirmation
+        """
+        response = StatusResponse(False)
+
+        try:
+            self.connect()
+            # Test the connection by getting user stats
+            test_response = self.connection.get_user_stats()
+            if test_response.get("result"):
+                logger.info("Successfully connected to Raindrop.io API")
+                response.success = True
+            else:
+                logger.error("Failed to connect to Raindrop.io API")
+                response.error_message = "Invalid API response"
+        except Exception as e:
+            logger.error(f"Error connecting to Raindrop.io API: {e}!")
+            response.error_message = str(e)
+
+        self.is_connected = response.success
+        return response
+
+    def native_query(self, query: str) -> StatusResponse:
+        """Receive and process a raw query.
+
+        Parameters
+        ----------
+        query : str
+            query in a native format
+
+        Returns
+        -------
+        StatusResponse
+            Request status
+        """
+        ast = parse_sql(query)
+        return self.query(ast)
+
+
+class RaindropAPIClient:
+    """A client for the Raindrop.io API"""
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.base_url = "https://api.raindrop.io/rest/v1"
+        self.headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+        # Rate limiting: 120 requests per minute = 2 requests per second
+        self.rate_limit_per_second = 2
+        self.request_times = []
+
+    def _apply_rate_limit(self):
+        """Apply rate limiting to avoid hitting API limits"""
+        current_time = time.time()
+
+        # Remove requests older than 1 second
+        self.request_times = [t for t in self.request_times if current_time - t < 1.0]
+
+        # Check if we need to wait
+        if len(self.request_times) >= self.rate_limit_per_second:
+            # Calculate how long to wait
+            oldest_request = min(self.request_times)
+            wait_time = 1.0 - (current_time - oldest_request)
+
+            if wait_time > 0:
+                logger.debug(f"Rate limit: waiting {wait_time:.2f} seconds")
+                time.sleep(wait_time)
+                # Update current_time after sleep
+                current_time = time.time()
+                # Clean up old requests again after sleep
+                self.request_times = [t for t in self.request_times if current_time - t < 1.0]
+
+        # Record this request
+        self.request_times.append(current_time)
+
+    def _make_request(
+        self, method: str, endpoint: str, params: Dict[str, Any] = None, data: Dict[str, Any] = None
+    ) -> Dict[str, Any]:
+        """Make a request to the Raindrop.io API with rate limiting"""
+        # Apply rate limiting
+        self._apply_rate_limit()
+
+        # Validate endpoint to prevent path traversal/injection attacks
+        allowed_endpoints = [
+            "/user/stats",
+            "/raindrops",
+            "/raindrop",
+            "/collections",
+            "/collection",
+            "/filters",
+            "/tags",
+            "/parse",
+        ]
+
+        # Normalize endpoint by ensuring it starts with /
+        normalized_endpoint = f"/{endpoint.lstrip('/')}"
+
+        # Check if endpoint matches any allowed prefix
+        if not any(normalized_endpoint.startswith(prefix) for prefix in allowed_endpoints):
+            raise ValueError(f"Invalid endpoint: {endpoint}. Only Raindrop.io API endpoints are allowed.")
+
+        url = f"{self.base_url}{normalized_endpoint}"
+
+        response = requests.request(method=method, url=url, headers=self.headers, params=params, json=data)
+
+        try:
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as e:
+            try:
+                error_data = response.json()
+                error_message = error_data.get("error", error_data.get("message", str(e)))
+            except (ValueError, KeyError):
+                error_message = str(e)
+            raise Exception(f"Raindrop API error: {error_message}")
+        return response.json()
+
+    def get_user_stats(self) -> Dict[str, Any]:
+        """Get user statistics"""
+        return self._make_request("GET", "/user/stats")
+
+    # Raindrops (Bookmarks) methods
+    def get_raindrops(
+        self,
+        collection_id: int = 0,
+        search: str = None,
+        sort: str = None,
+        page: int = 0,
+        per_page: int = 50,
+        max_results: int = None,
+    ) -> Dict[str, Any]:
+        """Get raindrops from a collection with optimized pagination"""
+        all_items = []
+        current_page = page
+
+        # Optimize page size based on max_results to minimize API calls
+        if max_results and max_results <= 10:
+            # For small limits, use smaller page sizes to avoid wasting requests
+            per_page_limit = max(5, min(per_page, max_results))
+        elif max_results and max_results <= 25:
+            per_page_limit = max(10, min(per_page, max_results))
+        else:
+            per_page_limit = min(per_page, 50)  # API limit is 50
+
+        while True:
+            params = {"page": current_page, "perpage": per_page_limit}
+
+            if search:
+                params["search"] = search
+            if sort:
+                params["sort"] = sort
+
+            response = self._make_request("GET", f"/raindrops/{collection_id}", params=params)
+
+            if not response.get("result", False):
+                break
+
+            items = response.get("items", [])
+            if not items:
+                break
+
+            all_items.extend(items)
+
+            # Check if we've reached max_results limit
+            if max_results and len(all_items) >= max_results:
+                all_items = all_items[:max_results]
+                break
+
+            # Check if we got fewer items than requested (last page)
+            if len(items) < per_page_limit:
+                break
+
+            current_page += 1
+
+            # Safety check: don't fetch more than 100 pages to prevent infinite loops and excessive API calls
+            # This allows fetching up to 5,000 bookmarks (100 pages * 50 per page)
+            if current_page > 100:
+                logger.warning("Stopping pagination after 100 pages to prevent excessive API usage")
+                break
+
+        # Return response in same format as original API
+        return {"result": True, "items": all_items, "count": len(all_items)}
+
+    def get_raindrop(self, raindrop_id: int) -> Dict[str, Any]:
+        """Get a single raindrop"""
+        return self._make_request("GET", f"/raindrop/{raindrop_id}")
+
+    def create_raindrop(self, raindrop_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new raindrop"""
+        return self._make_request("POST", "/raindrop", data=raindrop_data)
+
+    def update_raindrop(self, raindrop_id: int, raindrop_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update an existing raindrop"""
+        return self._make_request("PUT", f"/raindrop/{raindrop_id}", data=raindrop_data)
+
+    def delete_raindrop(self, raindrop_id: int) -> Dict[str, Any]:
+        """Delete a raindrop"""
+        return self._make_request("DELETE", f"/raindrop/{raindrop_id}")
+
+    def create_multiple_raindrops(self, raindrops_data: list) -> Dict[str, Any]:
+        """Create multiple raindrops"""
+        return self._make_request("POST", "/raindrops", data={"items": raindrops_data})
+
+    def update_multiple_raindrops(
+        self, collection_id: int, update_data: Dict[str, Any], search: str = None, ids: list = None
+    ) -> Dict[str, Any]:
+        """Update multiple raindrops"""
+        data = update_data.copy()
+        if search:
+            data["search"] = search
+        if ids:
+            data["ids"] = ids
+        return self._make_request("PUT", f"/raindrops/{collection_id}", data=data)
+
+    def delete_multiple_raindrops(self, collection_id: int, search: str = None, ids: list = None) -> Dict[str, Any]:
+        """Delete multiple raindrops"""
+        data = {}
+        if search:
+            data["search"] = search
+        if ids:
+            data["ids"] = ids
+        return self._make_request("DELETE", f"/raindrops/{collection_id}", data=data)
+
+    def move_raindrops_to_collection(
+        self, target_collection_id: int, source_collection_id: int = None, search: str = None, ids: list = None
+    ) -> Dict[str, Any]:
+        """Move raindrops to a different collection"""
+        update_data = {"collection": {"$id": target_collection_id}}
+        data = update_data.copy()
+        if search:
+            data["search"] = search
+        if ids:
+            data["ids"] = ids
+
+        endpoint = f"/raindrops/{source_collection_id}" if source_collection_id else "/raindrops/0"
+        return self._make_request("PUT", endpoint, data=data)
+
+    # Collections methods
+    def get_collections(self) -> Dict[str, Any]:
+        """Get all collections (root and nested)"""
+        return self._make_request("GET", "/collections")
+
+    def get_collection(self, collection_id: int) -> Dict[str, Any]:
+        """Get a single collection"""
+        return self._make_request("GET", f"/collection/{collection_id}")
+
+    def create_collection(self, collection_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new collection"""
+        return self._make_request("POST", "/collection", data=collection_data)
+
+    def update_collection(self, collection_id: int, collection_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update an existing collection"""
+        return self._make_request("PUT", f"/collection/{collection_id}", data=collection_data)
+
+    def delete_collection(self, collection_id: int) -> Dict[str, Any]:
+        """Delete a collection"""
+        return self._make_request("DELETE", f"/collection/{collection_id}")
+
+    def delete_multiple_collections(self, collection_ids: list) -> Dict[str, Any]:
+        """Delete multiple collections"""
+        return self._make_request("DELETE", "/collections", data={"ids": collection_ids})
+
+    # Advanced filtering methods
+    def get_raindrops_with_filters(self, collection_id: int = 0, filters: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Get raindrops using advanced filters endpoint"""
+        endpoint = f"/filters/{collection_id}"
+        return self._make_request("POST", endpoint, data=filters or {})
+
+    def get_tags(self) -> Dict[str, Any]:
+        """Get all tags with usage statistics"""
+        return self._make_request("GET", "/tags")
+
+    def parse_url(self, url: str) -> Dict[str, Any]:
+        """Parse URL to extract metadata"""
+        return self._make_request("POST", "/parse", data={"url": url})
+
+    def search_raindrops_advanced(
+        self,
+        collection_id: int = 0,
+        search: str = None,
+        tags: List[str] = None,
+        important: bool = None,
+        sort: str = None,
+        page: int = 0,
+        per_page: int = 50,
+    ) -> Dict[str, Any]:
+        """Advanced search with multiple filter criteria"""
+        filters = {}
+
+        if search:
+            filters["search"] = search
+        if tags:
+            filters["tags"] = tags
+        if important is not None:
+            filters["important"] = important
+        if sort:
+            filters["sort"] = sort
+
+        # Add pagination parameters to filters if provided
+        if page is not None:
+            filters["page"] = page
+        if per_page is not None:
+            filters["perpage"] = per_page
+
+        response = self.get_raindrops_with_filters(collection_id, filters)
+        return response
diff --git a/mindsdb/integrations/handlers/raindrop_handler/raindrop_tables.py b/mindsdb/integrations/handlers/raindrop_handler/raindrop_tables.py
new file mode 100644
index 00000000000..c667dd5fa29
--- /dev/null
+++ b/mindsdb/integrations/handlers/raindrop_handler/raindrop_tables.py
@@ -0,0 +1,1784 @@
+import pandas as pd
+from typing import List, Dict, Any
+
+from mindsdb_sql_parser import ast
+from mindsdb.integrations.libs.api_handler import APITable
+
+from mindsdb.integrations.utilities.handlers.query_utilities.select_query_utilities import (
+    SELECTQueryParser,
+    SELECTQueryExecutor,
+)
+from mindsdb.integrations.utilities.handlers.query_utilities.delete_query_utilities import (
+    DELETEQueryParser,
+    DELETEQueryExecutor,
+)
+from mindsdb.integrations.utilities.handlers.query_utilities.update_query_utilities import (
+    UPDATEQueryParser,
+    UPDATEQueryExecutor,
+)
+from mindsdb.integrations.utilities.handlers.query_utilities import INSERTQueryParser
+
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+
+class RaindropsTable(APITable):
+    """The Raindrop.io Raindrops (Bookmarks) Table implementation"""
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        """
+        Pulls Raindrop.io raindrops data.
+
+        Parameters
+        ----------
+        query : ast.Select
+           Given SQL SELECT query
+
+        Returns
+        -------
+        pd.DataFrame
+            Raindrop.io raindrops matching the query
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        select_statement_parser = SELECTQueryParser(query, "raindrops", self.get_columns())
+        (
+            selected_columns,
+            where_conditions,
+            order_by_conditions,
+            result_limit,
+        ) = select_statement_parser.parse_query()
+
+        # Parse WHERE conditions for Raindrop.io specific filters
+        collection_id = 0  # Default to All bookmarks
+        search_query = None
+        sort_order = None
+        raindrop_ids = []
+        api_supported_conditions = []  # Conditions that can be handled by Raindrop.io API
+        local_filter_conditions = []  # Conditions that need local filtering
+
+        # Parse conditions and categorize them
+        parsed_conditions = self._parse_where_conditions(where_conditions)
+        collection_id = parsed_conditions.get("collection_id", 0)
+        search_query = parsed_conditions.get("search")
+        sort_order = parsed_conditions.get("sort")
+        raindrop_ids = parsed_conditions.get("raindrop_ids", [])
+        api_supported_conditions = parsed_conditions.get("api_supported", [])
+        local_filter_conditions = parsed_conditions.get("local_filters", [])
+        complex_filters = parsed_conditions.get("complex_filters", {})
+
+        # Handle sorting
+        if order_by_conditions:
+            for order_condition in order_by_conditions:
+                if order_condition.column in ["created", "lastUpdate", "sort", "title"]:
+                    if order_condition.ascending:
+                        sort_order = order_condition.column
+                    else:
+                        sort_order = f"-{order_condition.column}"
+                    break
+
+        # If specific IDs are requested, try to fetch efficiently
+        if raindrop_ids:
+            raindrops_data = []
+            # Process IDs individually with rate limiting
+            # Raindrop.io doesn't have bulk get endpoints, so we need to be careful with rate limits
+            for raindrop_id in raindrop_ids:
+                try:
+                    response = self.handler.connection.get_raindrop(raindrop_id)
+                    if response.get("result") and response.get("item"):
+                        raindrops_data.append(response["item"])
+                except Exception as e:
+                    logger.warning(f"Failed to fetch raindrop {raindrop_id}: {e}")
+                    continue
+        else:
+            # Check if we can use advanced filtering endpoint
+            if complex_filters and self._can_use_advanced_filters(complex_filters):
+                # Use advanced filtering endpoint
+                try:
+                    response = self.handler.connection.get_raindrops_with_filters(
+                        collection_id=collection_id, filters=complex_filters
+                    )
+                    raindrops_data = response.get("items", [])
+
+                    # If advanced filtering worked, we might still need to apply local filters
+                    # for conditions not supported by the advanced endpoint
+                    if local_filter_conditions:
+                        # Convert to DataFrame for local filtering
+                        if raindrops_data:
+                            temp_df = pd.json_normalize(raindrops_data)
+                            temp_df = self._normalize_raindrop_data(temp_df)
+                            temp_df = self._apply_local_filters(temp_df, local_filter_conditions)
+                            raindrops_data = temp_df.to_dict("records")
+
+                except Exception as e:
+                    logger.warning(f"Advanced filtering failed, falling back to standard endpoint: {e}")
+                    # Fall back to standard endpoint
+                    raindrops_data = self._fetch_with_standard_endpoint(
+                        collection_id, search_query, sort_order, result_limit, local_filter_conditions
+                    )
+            else:
+                # Use standard endpoint
+                raindrops_data = self._fetch_with_standard_endpoint(
+                    collection_id, search_query, sort_order, result_limit, local_filter_conditions
+                )
+
+        # Convert to DataFrame
+        if raindrops_data:
+            raindrops_df = pd.json_normalize(raindrops_data)
+            raindrops_df = self._normalize_raindrop_data(raindrops_df)
+        else:
+            # Create empty DataFrame with all expected columns
+            raindrops_df = pd.DataFrame(columns=self.get_columns())
+
+        # Ensure all expected columns exist (defensive check)
+        expected_columns = self.get_columns()
+        for col in expected_columns:
+            if col not in raindrops_df.columns:
+                logger.warning(f"Missing column after normalization: {col}, adding as None")
+                raindrops_df[col] = None
+
+        # Apply local filtering for advanced conditions
+        if local_filter_conditions:
+            raindrops_df = self._apply_local_filters(raindrops_df, local_filter_conditions)
+
+        # Apply additional filtering and ordering using the executor (for any remaining conditions)
+        remaining_conditions = [
+            cond
+            for cond in where_conditions
+            if cond not in api_supported_conditions and cond not in local_filter_conditions
+        ]
+        if remaining_conditions:
+            select_statement_executor = SELECTQueryExecutor(
+                raindrops_df, selected_columns, remaining_conditions, order_by_conditions
+            )
+            raindrops_df = select_statement_executor.execute_query()
+        else:
+            # Apply ordering and column selection manually if no remaining conditions
+            if order_by_conditions:
+                raindrops_df = self._apply_ordering(raindrops_df, order_by_conditions)
+            if selected_columns and selected_columns != self.get_columns():
+                available_columns = [col for col in selected_columns if col in raindrops_df.columns]
+                if available_columns:
+                    raindrops_df = raindrops_df[available_columns]
+
+        # Apply limit if needed
+        # Don't apply the default limit (20) when local filters were used, as this would
+        # artificially limit results when the user didn't specify a LIMIT
+        should_apply_limit = result_limit and (
+            result_limit != 20  # Not the default limit
+            or not local_filter_conditions  # No local filters were applied
+        )
+        if should_apply_limit and len(raindrops_df) > result_limit:
+            raindrops_df = raindrops_df.head(result_limit)
+
+        return raindrops_df
+
+    def insert(self, query: ast.Insert) -> None:
+        """
+        Inserts data into the Raindrop.io raindrops.
+
+        Parameters
+        ----------
+        query : ast.Insert
+           Given SQL INSERT query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        insert_statement_parser = INSERTQueryParser(query)
+        values_to_insert = insert_statement_parser.parse_query()
+
+        # Process multiple or single inserts
+        if isinstance(values_to_insert, list):
+            # Multiple inserts
+            raindrops_data = []
+            for row in values_to_insert:
+                raindrop_data = self._prepare_raindrop_data(row)
+                raindrops_data.append(raindrop_data)
+
+            # Use batch insert if more than one item
+            if len(raindrops_data) > 1:
+                self.handler.connection.create_multiple_raindrops(raindrops_data)
+            else:
+                self.handler.connection.create_raindrop(raindrops_data[0])
+        else:
+            # Single insert
+            raindrop_data = self._prepare_raindrop_data(values_to_insert)
+            self.handler.connection.create_raindrop(raindrop_data)
+
+    def update(self, query: ast.Update) -> None:
+        """
+        Updates data in the Raindrop.io raindrops.
+
+        Parameters
+        ----------
+        query : ast.Update
+           Given SQL UPDATE query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        update_statement_parser = UPDATEQueryParser(query)
+        values_to_update, where_conditions = update_statement_parser.parse_query()
+
+        # Extract specific IDs and collection filters from WHERE conditions to avoid loading all data
+        raindrop_ids = []
+        collection_id = None
+        search_query = None
+
+        for condition in where_conditions:
+            if condition.column in ["_id", "id"]:
+                if isinstance(condition.value, list):
+                    raindrop_ids.extend(condition.value)
+                else:
+                    raindrop_ids.append(condition.value)
+            elif condition.column == "collection_id":
+                collection_id = condition.value
+            elif condition.column in ["search", "title"]:
+                search_query = condition.value
+
+        # If we have specific IDs, update them directly without loading all data
+        if raindrop_ids:
+            for raindrop_id in raindrop_ids:
+                try:
+                    update_data = self._prepare_raindrop_data(values_to_update)
+                    self.handler.connection.update_raindrop(raindrop_id, update_data)
+                except Exception as e:
+                    logger.error(f"Failed to update raindrop {raindrop_id}: {e}")
+            return
+
+        # For complex filters, fetch only relevant data based on conditions
+        fetch_params = {}
+        if collection_id is not None:
+            fetch_params["collection_id"] = collection_id
+        if search_query:
+            fetch_params["search"] = search_query
+
+        # Fetch only the relevant subset of data
+        raindrops_data = self.get_raindrops(**fetch_params)
+
+        if not raindrops_data:
+            logger.warning("No raindrops found matching the WHERE conditions")
+            return
+
+        raindrops_df = pd.json_normalize(raindrops_data)
+        raindrops_df = self._normalize_raindrop_data(raindrops_df)
+
+        # Apply remaining filters
+        update_query_executor = UPDATEQueryExecutor(raindrops_df, where_conditions)
+        raindrops_df = update_query_executor.execute_query()
+
+        if raindrops_df.empty:
+            logger.warning("No raindrops found matching the WHERE conditions")
+            return
+
+        raindrop_ids = raindrops_df["_id"].tolist()
+
+        # Check if we should do bulk update or individual updates
+        if len(raindrop_ids) > 1:
+            # Try bulk update first
+            collection_id = raindrops_df["collection.$id"].iloc[0] if "collection.$id" in raindrops_df.columns else 0
+
+            try:
+                update_data = self._prepare_raindrop_data(values_to_update)
+                self.handler.connection.update_multiple_raindrops(
+                    collection_id=collection_id, update_data=update_data, ids=raindrop_ids
+                )
+            except Exception as e:
+                logger.warning(f"Bulk update failed, falling back to individual updates: {e}")
+                # Fall back to individual updates
+                for raindrop_id in raindrop_ids:
+                    try:
+                        update_data = self._prepare_raindrop_data(values_to_update)
+                        self.handler.connection.update_raindrop(raindrop_id, update_data)
+                    except Exception as e:
+                        logger.error(f"Failed to update raindrop {raindrop_id}: {e}")
+        else:
+            # Single update
+            raindrop_id = raindrop_ids[0]
+            update_data = self._prepare_raindrop_data(values_to_update)
+            self.handler.connection.update_raindrop(raindrop_id, update_data)
+
+    def delete(self, query: ast.Delete) -> None:
+        """
+        Deletes data from the Raindrop.io raindrops.
+
+        Parameters
+        ----------
+        query : ast.Delete
+           Given SQL DELETE query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        delete_statement_parser = DELETEQueryParser(query)
+        where_conditions = delete_statement_parser.parse_query()
+
+        # Extract specific IDs and collection filters from WHERE conditions to avoid loading all data
+        raindrop_ids = []
+        collection_id = None
+        search_query = None
+
+        for condition in where_conditions:
+            if condition.column in ["_id", "id"]:
+                if isinstance(condition.value, list):
+                    raindrop_ids.extend(condition.value)
+                else:
+                    raindrop_ids.append(condition.value)
+            elif condition.column == "collection_id":
+                collection_id = condition.value
+            elif condition.column in ["search", "title"]:
+                search_query = condition.value
+
+        # If we have specific IDs, delete them directly without loading all data
+        if raindrop_ids:
+            if len(raindrop_ids) > 1 and collection_id is not None:
+                # Try bulk delete if we know the collection
+                try:
+                    self.handler.connection.delete_multiple_raindrops(collection_id=collection_id, ids=raindrop_ids)
+                    return
+                except Exception as e:
+                    logger.warning(f"Bulk delete failed, falling back to individual deletes: {e}")
+
+            # Individual deletes
+            for raindrop_id in raindrop_ids:
+                try:
+                    self.handler.connection.delete_raindrop(raindrop_id)
+                except Exception as e:
+                    logger.error(f"Failed to delete raindrop {raindrop_id}: {e}")
+            return
+
+        # For complex filters, fetch only relevant data based on conditions
+        fetch_params = {}
+        if collection_id is not None:
+            fetch_params["collection_id"] = collection_id
+        if search_query:
+            fetch_params["search"] = search_query
+
+        # Fetch only the relevant subset of data
+        raindrops_data = self.get_raindrops(**fetch_params)
+
+        if not raindrops_data:
+            logger.warning("No raindrops found matching the WHERE conditions")
+            return
+
+        raindrops_df = pd.json_normalize(raindrops_data)
+        raindrops_df = self._normalize_raindrop_data(raindrops_df)
+
+        # Apply remaining filters
+        delete_query_executor = DELETEQueryExecutor(raindrops_df, where_conditions)
+        raindrops_df = delete_query_executor.execute_query()
+
+        if raindrops_df.empty:
+            logger.warning("No raindrops found matching the WHERE conditions")
+            return
+
+        raindrop_ids = raindrops_df["_id"].tolist()
+
+        # Check if we should do bulk delete or individual deletes
+        if len(raindrop_ids) > 1:
+            # Try bulk delete first
+            collection_id = raindrops_df["collection.$id"].iloc[0] if "collection.$id" in raindrops_df.columns else 0
+
+            try:
+                self.handler.connection.delete_multiple_raindrops(collection_id=collection_id, ids=raindrop_ids)
+            except Exception as e:
+                logger.warning(f"Bulk delete failed, falling back to individual deletes: {e}")
+                # Fall back to individual deletes
+                for raindrop_id in raindrop_ids:
+                    try:
+                        self.handler.connection.delete_raindrop(raindrop_id)
+                    except Exception as e:
+                        logger.error(f"Failed to delete raindrop {raindrop_id}: {e}")
+        else:
+            # Single delete
+            raindrop_id = raindrop_ids[0]
+            self.handler.connection.delete_raindrop(raindrop_id)
+
+    def get_columns(self) -> List[str]:
+        """Get the column names for the raindrops table"""
+        return [
+            "_id",
+            "link",
+            "title",
+            "excerpt",
+            "note",
+            "type",
+            "cover",
+            "tags",
+            "important",
+            "reminder",
+            "removed",
+            "created",
+            "lastUpdate",
+            "domain",
+            "collection.id",
+            "collection.title",
+            "user.id",
+            "broken",
+            "cache",
+            "file.name",
+            "file.size",
+            "file.type",
+        ]
+
+    def get_raindrops(self, **kwargs) -> List[Dict]:
+        """Get raindrops data"""
+        if not self.handler.connection:
+            self.handler.connect()
+
+        # Get from all collections by default
+        response = self.handler.connection.get_raindrops(**kwargs)
+        return response.get("items", [])
+
+    def _normalize_raindrop_data(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Normalize raindrop data for consistent column structure"""
+        if df.empty:
+            return df
+
+        # Process nested data first to extract flattened columns
+        try:
+            # Handle nested collection data
+            if "collection" in df.columns:
+                df["collection.id"] = df["collection"].apply(lambda x: x.get("$id") if isinstance(x, dict) else None)
+                df["collection.$id"] = df["collection"].apply(lambda x: x.get("$id") if isinstance(x, dict) else None)
+                df["collection.title"] = df["collection"].apply(
+                    lambda x: x.get("title") if isinstance(x, dict) else None
+                )
+        except Exception as e:
+            logger.warning(f"Error processing collection data: {e}")
+
+        try:
+            # Handle nested user data
+            if "user" in df.columns:
+                df["user.id"] = df["user"].apply(lambda x: x.get("$id") if isinstance(x, dict) else None)
+        except Exception as e:
+            logger.warning(f"Error processing user data: {e}")
+
+        try:
+            # Handle nested file data
+            if "file" in df.columns:
+                df["file.name"] = df["file"].apply(lambda x: x.get("name") if isinstance(x, dict) else None)
+                df["file.size"] = df["file"].apply(lambda x: x.get("size") if isinstance(x, dict) else None)
+                df["file.type"] = df["file"].apply(lambda x: x.get("type") if isinstance(x, dict) else None)
+        except Exception as e:
+            logger.warning(f"Error processing file data: {e}")
+
+        # Convert tags list to string
+        try:
+            if "tags" in df.columns:
+                df["tags"] = df["tags"].apply(lambda x: ",".join(x) if isinstance(x, list) else x)
+        except Exception as e:
+            logger.warning(f"Error processing tags data: {e}")
+
+        # Convert dates
+        for date_col in ["created", "lastUpdate"]:
+            try:
+                if date_col in df.columns:
+                    df[date_col] = pd.to_datetime(df[date_col], errors="coerce")
+            except Exception as e:
+                logger.warning(f"Error processing date column {date_col}: {e}")
+
+        # Ensure ALL expected columns exist, even if empty
+        # This must happen LAST to ensure any newly created columns are preserved
+        expected_columns = self.get_columns()
+        for col in expected_columns:
+            if col not in df.columns:
+                df[col] = None
+
+        return df
+
+    def _apply_local_filters(self, df: pd.DataFrame, conditions: List) -> pd.DataFrame:
+        """Apply local filtering for conditions not supported by Raindrop.io API"""
+        if df.empty or not conditions:
+            return df
+
+        for condition in conditions:
+            # Handle different condition formats
+            if isinstance(condition, list) and len(condition) >= 3:
+                op, column, value = condition[0], condition[1], condition[2]
+            elif hasattr(condition, "op") and hasattr(condition, "column"):
+                op = getattr(condition, "op", "=")
+                column = condition.column
+                value = getattr(condition, "value", None)
+            else:
+                # Skip malformed conditions
+                logger.warning(f"Skipping malformed condition in local filter: {condition}")
+                continue
+
+            if column not in df.columns:
+                logger.warning(f"Column '{column}' not found in DataFrame, skipping filter")
+                continue
+
+            try:
+                if op == "=":
+                    if isinstance(value, bool):
+                        df = df[df[column] == value]
+                    else:
+                        df = df[df[column].astype(str).str.lower() == str(value).lower()]
+                elif op == "!=":
+                    df = df[df[column] != value]
+                elif op == ">":
+                    if column in ["created", "lastUpdate"]:
+                        # Convert string dates to datetime for comparison
+                        df[column] = pd.to_datetime(df[column], errors="coerce")
+                        value = pd.to_datetime(value)
+                    df = df[df[column] > value]
+                elif op == "<":
+                    if column in ["created", "lastUpdate"]:
+                        df[column] = pd.to_datetime(df[column], errors="coerce")
+                        value = pd.to_datetime(value)
+                    df = df[df[column] < value]
+                elif op == ">=":
+                    if column in ["created", "lastUpdate"]:
+                        df[column] = pd.to_datetime(df[column], errors="coerce")
+                        value = pd.to_datetime(value)
+                    df = df[df[column] >= value]
+                elif op == "<=":
+                    if column in ["created", "lastUpdate"]:
+                        df[column] = pd.to_datetime(df[column], errors="coerce")
+                        value = pd.to_datetime(value)
+                    df = df[df[column] <= value]
+                elif op == "between":
+                    if column in ["created", "lastUpdate"]:
+                        df[column] = pd.to_datetime(df[column], errors="coerce")
+                        start_val, end_val = pd.to_datetime(value[0]), pd.to_datetime(value[1])
+                    else:
+                        start_val, end_val = value
+                    df = df[(df[column] >= start_val) & (df[column] <= end_val)]
+                elif op == "like":
+                    # Simple LIKE implementation
+                    pattern = str(value).replace("%", ".*").replace("_", ".")
+                    df = df[df[column].astype(str).str.contains(pattern, case=False, regex=True, na=False)]
+                elif op == "in":
+                    if isinstance(value, list):
+                        df = df[df[column].isin(value)]
+                    else:
+                        df = df[df[column] == value]
+                else:
+                    logger.warning(f"Unsupported operator '{op}' for column '{column}', skipping filter")
+
+            except Exception as e:
+                logger.warning(f"Error applying filter {op} on column '{column}': {e}")
+                continue
+
+        return df
+
+    def _parse_where_conditions(self, conditions: List) -> Dict[str, Any]:
+        """Parse WHERE conditions and categorize them for different handling strategies"""
+        parsed = {
+            "collection_id": 0,
+            "search": None,
+            "sort": None,
+            "raindrop_ids": [],
+            "api_supported": [],
+            "local_filters": [],
+            "complex_filters": {},
+        }
+
+        # Collect all search-related conditions for potential optimization
+        search_conditions = []
+
+        for condition in conditions:
+            # Handle different condition formats
+            if isinstance(condition, list) and len(condition) >= 3:
+                op, column, value = condition[0], condition[1], condition[2]
+            elif hasattr(condition, "op") and hasattr(condition, "column"):
+                op = getattr(condition, "op", "=")
+                column = condition.column
+                value = getattr(condition, "value", None)
+            else:
+                # Skip malformed conditions
+                logger.warning(f"Skipping malformed condition: {condition}")
+                continue
+
+            # Collect search-related conditions for optimization
+            if self._is_search_condition(column, op):
+                search_conditions.append((column, op, value, condition))
+
+            # Categorize conditions based on API support and complexity
+            # Defer search-related conditions until after optimization
+            if column == "collection_id" and op == "=":
+                parsed["collection_id"] = value
+                parsed["api_supported"].append(condition)
+            elif column == "search" and op == "=":
+                # Only handle direct search conditions, defer field-specific searches
+                parsed["search"] = value
+                parsed["api_supported"].append(condition)
+            elif (column in ["_id", "id"]) and op in ["=", "in"]:
+                if isinstance(value, list):
+                    parsed["raindrop_ids"].extend(value)
+                else:
+                    parsed["raindrop_ids"].append(value)
+                parsed["api_supported"].append(condition)
+            # Handle advanced conditions that need local filtering
+            elif column in ["created", "lastUpdate", "sort"] and op in [">", "<", ">=", "<=", "between"]:
+                parsed["local_filters"].append(condition)
+            elif column == "important" and op == "=":
+                parsed["local_filters"].append(condition)
+            elif column in ["domain"] and op in ["=", "like", "in"]:
+                # Only handle domain, defer other text fields until optimization
+                parsed["local_filters"].append(condition)
+            elif not self._is_search_condition(column, op):
+                # For non-search conditions, add to local filtering immediately
+                parsed["local_filters"].append(condition)
+            # Search-related conditions (title, excerpt, note, tags with = or like) are deferred
+
+        # Optimize search conditions before final categorization
+        self._optimize_search_conditions(search_conditions, parsed)
+
+        # Now categorize any remaining search conditions that weren't optimized
+        for column, op, value, original_condition in search_conditions:
+            if original_condition not in parsed["api_supported"] and original_condition not in parsed["local_filters"]:
+                # This condition wasn't optimized, add it to local filters
+                parsed["local_filters"].append(original_condition)
+
+        # Build complex filters for advanced API endpoint if we have multiple criteria
+        if parsed["search"] or parsed["local_filters"]:
+            complex_filters = {}
+            if parsed["search"]:
+                complex_filters["search"] = parsed["search"]
+
+            # Extract important flag if present in local filters
+            for condition in parsed["local_filters"]:
+                if isinstance(condition, list) and len(condition) >= 3:
+                    op, column, value = condition[0], condition[1], condition[2]
+                elif hasattr(condition, "op") and hasattr(condition, "column"):
+                    op = getattr(condition, "op", "=")
+                    column = condition.column
+                    value = getattr(condition, "value", None)
+                else:
+                    continue
+
+                if column == "important" and op == "=":
+                    complex_filters["important"] = value
+                elif column == "tags" and op in ["=", "in"]:
+                    if isinstance(value, list):
+                        complex_filters["tags"] = value
+                    else:
+                        complex_filters["tags"] = [value]
+
+            if complex_filters:
+                parsed["complex_filters"] = complex_filters
+
+        return parsed
+
+    def _is_search_condition(self, column: str, op: str) -> bool:
+        """Check if a condition is search-related"""
+        return ((column in ["search", "title", "excerpt", "note", "tags"]) and op in ["=", "like"]) or (
+            column == "search" and op == "="
+        )
+
+    def _optimize_search_conditions(self, search_conditions: List, parsed: Dict[str, Any]) -> None:
+        """Optimize multiple search conditions into a single API search query"""
+        if not search_conditions:
+            return
+
+        # Check if we have a direct search condition (user explicitly specified search)
+        has_direct_search = any(column == "search" and op == "=" for column, op, _, _ in search_conditions)
+
+        # If user specified a direct search, still process other conditions but don't combine them
+        # into the search query - just mark them as API supported if they can be optimized
+
+        # Collect all text-based search terms
+        search_terms = []
+        like_conditions = []
+
+        for column, op, value, original_condition in search_conditions:
+            if op == "=" and column in ["title", "excerpt", "note"]:
+                # If we have a direct search, don't combine field-specific searches
+                # but still mark them as API supported if they can be optimized
+                if not has_direct_search:
+                    # Convert field-specific searches to general search terms
+                    if column == "title":
+                        search_terms.append(f"title:{value}")
+                    elif column == "excerpt":
+                        search_terms.append(f"excerpt:{value}")
+                    elif column == "note":
+                        search_terms.append(f"note:{value}")
+
+                # Remove from local filters and mark as API supported
+                if original_condition in parsed["local_filters"]:
+                    parsed["local_filters"].remove(original_condition)
+                if original_condition not in parsed["api_supported"]:
+                    parsed["api_supported"].append(original_condition)
+
+            elif op == "like" and column in ["title", "excerpt", "note", "tags"]:
+                like_conditions.append((column, op, value, original_condition))
+
+        # If we have multiple field-specific searches and no direct search, combine them
+        if search_terms and not has_direct_search:
+            combined_search = " ".join(search_terms)
+            if len(search_terms) > 1:
+                # For multiple terms, use AND logic
+                combined_search = f"({' AND '.join(search_terms)})"
+
+            parsed["search"] = combined_search
+
+        # Optimize simple LIKE patterns that can use API search
+        for column, op, value, original_condition in like_conditions:
+            if self._can_use_api_search_for_like(column, value):
+                # Convert simple LIKE patterns to API search
+                api_search_term = self._convert_like_to_api_search(column, value)
+                if api_search_term:
+                    if not has_direct_search:
+                        if parsed["search"]:
+                            parsed["search"] += f" {api_search_term}"
+                        else:
+                            parsed["search"] = api_search_term
+
+                    # Remove from local filters and mark as API supported
+                    if original_condition in parsed["local_filters"]:
+                        parsed["local_filters"].remove(original_condition)
+                    if original_condition not in parsed["api_supported"]:
+                        parsed["api_supported"].append(original_condition)
+
+    def _can_use_api_search_for_like(self, column: str, value: str) -> bool:
+        """Check if a LIKE pattern can be efficiently handled by API search"""
+        if not isinstance(value, str):
+            return False
+
+        # Only optimize simple patterns that start and end with %
+        if not (value.startswith("%") and value.endswith("%")):
+            return False
+
+        # Remove % and check if it's a simple word/pattern
+        pattern = value.strip("%")
+
+        # Don't optimize if pattern contains regex special chars, % in middle, or is too short
+        if len(pattern) < 3 or any(char in pattern for char in ".*+?^$()[]{}|\\") or "%" in pattern:
+            return False
+
+        return column in ["title", "excerpt", "note", "tags"]
+
+    def _convert_like_to_api_search(self, column: str, value: str) -> str:
+        """Convert LIKE pattern to API search format"""
+        if not isinstance(value, str):
+            return None
+
+        pattern = value.strip("%")
+
+        # Create field-specific search term
+        if column == "title":
+            return f"title:{pattern}"
+        elif column == "excerpt":
+            return f"excerpt:{pattern}"
+        elif column == "note":
+            return f"note:{pattern}"
+        elif column == "tags":
+            return f"tag:{pattern}"
+
+        return pattern
+
+    def _can_use_advanced_filters(self, complex_filters: Dict[str, Any]) -> bool:
+        """Check if we can use the advanced filtering endpoint"""
+        # Use advanced filters if we have search, important, or tags criteria
+        return any(key in complex_filters for key in ["search", "important", "tags"])
+
+    def _fetch_with_standard_endpoint(
+        self, collection_id: int, search_query: str, sort_order: str, result_limit: int, local_filter_conditions: List
+    ) -> List[Dict]:
+        """Fetch data using the standard Raindrop.io endpoint"""
+        # If we have local filters, we may need to fetch more data than requested limit
+        # to ensure we have enough data to filter locally
+        fetch_limit = None
+        if local_filter_conditions:
+            # If we have local filters, fetch more data to account for filtering
+            # We'll apply the original limit after local filtering
+            if result_limit and result_limit != 20:  # 20 is the default limit when no LIMIT is specified
+                fetch_limit = result_limit * 5  # Fetch more data for local filtering
+            else:
+                fetch_limit = None  # Fetch all data when no limit specified or default limit
+        else:
+            fetch_limit = result_limit
+
+        response = self.handler.connection.get_raindrops(
+            collection_id=collection_id,
+            search=search_query,
+            sort=sort_order,
+            page=0,
+            per_page=50,
+            max_results=fetch_limit,
+        )
+        return response.get("items", [])
+
+    def _apply_ordering(self, df: pd.DataFrame, order_by_conditions) -> pd.DataFrame:
+        """Apply ordering to DataFrame"""
+        if not order_by_conditions or df.empty:
+            return df
+
+        sort_cols = []
+        ascending = []
+
+        for order_condition in order_by_conditions:
+            column = getattr(order_condition, "column", getattr(order_condition, "field", None))
+            if column and column in df.columns:
+                sort_cols.append(column)
+                ascending.append(getattr(order_condition, "ascending", True))
+
+        if sort_cols:
+            df = df.sort_values(by=sort_cols, ascending=ascending)
+
+        return df
+
+    def _prepare_raindrop_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Prepare raindrop data for API submission"""
+        raindrop_data = {}
+
+        # Map common fields
+        field_mappings = {
+            "link": "link",
+            "title": "title",
+            "excerpt": "excerpt",
+            "note": "note",
+            "type": "type",
+            "cover": "cover",
+            "important": "important",
+            "collection_id": "collection",
+            "collection.id": "collection",
+        }
+
+        for key, value in data.items():
+            if key in field_mappings:
+                api_key = field_mappings[key]
+                if api_key == "collection" and value:
+                    raindrop_data[api_key] = {"$id": int(value)}
+                elif key == "important" and value is not None:
+                    raindrop_data[api_key] = bool(value)
+                elif value is not None:
+                    raindrop_data[api_key] = value
+
+        # Handle tags (convert string to list)
+        if "tags" in data and data["tags"]:
+            if isinstance(data["tags"], str):
+                raindrop_data["tags"] = [tag.strip() for tag in data["tags"].split(",")]
+            elif isinstance(data["tags"], list):
+                raindrop_data["tags"] = data["tags"]
+
+        return raindrop_data
+
+
+class CollectionsTable(APITable):
+    """The Raindrop.io Collections Table implementation"""
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        """
+        Pulls Raindrop.io collections data.
+
+        Parameters
+        ----------
+        query : ast.Select
+           Given SQL SELECT query
+
+        Returns
+        -------
+        pd.DataFrame
+            Raindrop.io collections matching the query
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        select_statement_parser = SELECTQueryParser(query, "collections", self.get_columns())
+        (
+            selected_columns,
+            where_conditions,
+            order_by_conditions,
+            result_limit,
+        ) = select_statement_parser.parse_query()
+
+        # Get collections data
+        collections_data = self.get_collections()
+
+        # Convert to DataFrame
+        if collections_data:
+            collections_df = pd.json_normalize(collections_data)
+            collections_df = self._normalize_collection_data(collections_df)
+        else:
+            # Create empty DataFrame with all expected columns
+            collections_df = pd.DataFrame(columns=self.get_columns())
+
+        # Ensure all expected columns exist (defensive check)
+        expected_columns = self.get_columns()
+        for col in expected_columns:
+            if col not in collections_df.columns:
+                logger.warning(f"Missing column after normalization: {col}, adding as None")
+                collections_df[col] = None
+
+        # Apply filtering and ordering
+        select_statement_executor = SELECTQueryExecutor(
+            collections_df, selected_columns, where_conditions, order_by_conditions
+        )
+        collections_df = select_statement_executor.execute_query()
+
+        # Apply limit if needed
+        if result_limit and len(collections_df) > result_limit:
+            collections_df = collections_df.head(result_limit)
+
+        return collections_df
+
+    def insert(self, query: ast.Insert) -> None:
+        """
+        Inserts data into the Raindrop.io collections.
+
+        Parameters
+        ----------
+        query : ast.Insert
+           Given SQL INSERT query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        insert_statement_parser = INSERTQueryParser(query)
+        values_to_insert = insert_statement_parser.parse_query()
+
+        if isinstance(values_to_insert, list):
+            # Multiple inserts
+            for row in values_to_insert:
+                collection_data = self._prepare_collection_data(row)
+                self.handler.connection.create_collection(collection_data)
+        else:
+            # Single insert
+            collection_data = self._prepare_collection_data(values_to_insert)
+            self.handler.connection.create_collection(collection_data)
+
+    def update(self, query: ast.Update) -> None:
+        """
+        Updates data in the Raindrop.io collections.
+
+        Parameters
+        ----------
+        query : ast.Update
+           Given SQL UPDATE query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        update_statement_parser = UPDATEQueryParser(query)
+        values_to_update, where_conditions = update_statement_parser.parse_query()
+
+        # Extract specific IDs from WHERE conditions to avoid loading all data
+        collection_ids = []
+
+        for condition in where_conditions:
+            if condition.column in ["_id", "id"]:
+                if isinstance(condition.value, list):
+                    collection_ids.extend(condition.value)
+                else:
+                    collection_ids.append(condition.value)
+
+        # If we have specific IDs, update them directly without loading all data
+        if collection_ids:
+            for collection_id in collection_ids:
+                try:
+                    update_data = self._prepare_collection_data(values_to_update)
+                    self.handler.connection.update_collection(collection_id, update_data)
+                except Exception as e:
+                    logger.error(f"Failed to update collection {collection_id}: {e}")
+            return
+
+        # For complex filters, we need to fetch and filter collections
+        # Since collections are typically fewer in number than raindrops, this is more acceptable
+        collections_data = self.get_collections()
+
+        if not collections_data:
+            logger.warning("No collections found")
+            return
+
+        collections_df = pd.json_normalize(collections_data)
+        collections_df = self._normalize_collection_data(collections_df)
+
+        # Apply filters
+        update_query_executor = UPDATEQueryExecutor(collections_df, where_conditions)
+        collections_df = update_query_executor.execute_query()
+
+        if collections_df.empty:
+            logger.warning("No collections found matching the WHERE conditions")
+            return
+
+        collection_ids = collections_df["_id"].tolist()
+
+        # Update each collection individually
+        for collection_id in collection_ids:
+            try:
+                update_data = self._prepare_collection_data(values_to_update)
+                self.handler.connection.update_collection(collection_id, update_data)
+            except Exception as e:
+                logger.error(f"Failed to update collection {collection_id}: {e}")
+
+    def delete(self, query: ast.Delete) -> None:
+        """
+        Deletes data from the Raindrop.io collections.
+
+        Parameters
+        ----------
+        query : ast.Delete
+           Given SQL DELETE query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        delete_statement_parser = DELETEQueryParser(query)
+        where_conditions = delete_statement_parser.parse_query()
+
+        # Extract specific IDs from WHERE conditions to avoid loading all data
+        collection_ids = []
+
+        for condition in where_conditions:
+            if condition.column in ["_id", "id"]:
+                if isinstance(condition.value, list):
+                    collection_ids.extend(condition.value)
+                else:
+                    collection_ids.append(condition.value)
+
+        # If we have specific IDs, delete them directly without loading all data
+        if collection_ids:
+            if len(collection_ids) > 1:
+                try:
+                    self.handler.connection.delete_multiple_collections(collection_ids)
+                    return
+                except Exception as e:
+                    logger.warning(f"Bulk delete failed, falling back to individual deletes: {e}")
+
+            # Individual deletes
+            for collection_id in collection_ids:
+                try:
+                    self.handler.connection.delete_collection(collection_id)
+                except Exception as e:
+                    logger.error(f"Failed to delete collection {collection_id}: {e}")
+            return
+
+        # For complex filters, we need to fetch and filter collections
+        # Since collections are typically fewer in number than raindrops, this is more acceptable
+        collections_data = self.get_collections()
+
+        if not collections_data:
+            logger.warning("No collections found")
+            return
+
+        collections_df = pd.json_normalize(collections_data)
+        collections_df = self._normalize_collection_data(collections_df)
+
+        # Apply filters
+        delete_query_executor = DELETEQueryExecutor(collections_df, where_conditions)
+        collections_df = delete_query_executor.execute_query()
+
+        if collections_df.empty:
+            logger.warning("No collections found matching the WHERE conditions")
+            return
+
+        collection_ids = collections_df["_id"].tolist()
+
+        # Check if we should do bulk delete or individual deletes
+        if len(collection_ids) > 1:
+            try:
+                self.handler.connection.delete_multiple_collections(collection_ids)
+            except Exception as e:
+                logger.warning(f"Bulk delete failed, falling back to individual deletes: {e}")
+                # Fall back to individual deletes
+                for collection_id in collection_ids:
+                    try:
+                        self.handler.connection.delete_collection(collection_id)
+                    except Exception as e:
+                        logger.error(f"Failed to delete collection {collection_id}: {e}")
+        else:
+            # Single delete
+            collection_id = collection_ids[0]
+            self.handler.connection.delete_collection(collection_id)
+
+    def get_columns(self) -> List[str]:
+        """Get the column names for the collections table"""
+        return [
+            "_id",
+            "title",
+            "description",
+            "color",
+            "view",
+            "public",
+            "sort",
+            "count",
+            "created",
+            "lastUpdate",
+            "expanded",
+            "parent.id",
+            "user.id",
+            "cover",
+            "access.level",
+            "access.draggable",
+        ]
+
+    def get_collections(self, **kwargs) -> List[Dict]:
+        """Get collections data"""
+        if not self.handler.connection:
+            self.handler.connect()
+
+        # Get all collections (root and nested) from the main collections endpoint
+        response = self.handler.connection.get_collections()
+        return response.get("items", [])
+
+    def _normalize_collection_data(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Normalize collection data for consistent column structure"""
+        if df.empty:
+            return df
+
+        # Process nested data first to extract flattened columns
+        try:
+            # Handle nested parent data
+            if "parent" in df.columns:
+                df["parent.id"] = df["parent"].apply(lambda x: x.get("$id") if isinstance(x, dict) else None)
+        except Exception as e:
+            logger.warning(f"Error processing parent data: {e}")
+
+        try:
+            # Handle nested user data
+            if "user" in df.columns:
+                df["user.id"] = df["user"].apply(lambda x: x.get("$id") if isinstance(x, dict) else None)
+        except Exception as e:
+            logger.warning(f"Error processing user data: {e}")
+
+        try:
+            # Handle nested access data
+            if "access" in df.columns:
+                df["access.level"] = df["access"].apply(lambda x: x.get("level") if isinstance(x, dict) else None)
+                df["access.draggable"] = df["access"].apply(
+                    lambda x: x.get("draggable") if isinstance(x, dict) else None
+                )
+        except Exception as e:
+            logger.warning(f"Error processing access data: {e}")
+
+        # Convert cover list to string
+        try:
+            if "cover" in df.columns:
+                df["cover"] = df["cover"].apply(lambda x: x[0] if isinstance(x, list) and x else x)
+        except Exception as e:
+            logger.warning(f"Error processing cover data: {e}")
+
+        # Convert dates
+        for date_col in ["created", "lastUpdate"]:
+            try:
+                if date_col in df.columns:
+                    df[date_col] = pd.to_datetime(df[date_col], errors="coerce")
+            except Exception as e:
+                logger.warning(f"Error processing date column {date_col}: {e}")
+
+        # Ensure ALL expected columns exist, even if empty
+        # This must happen LAST to ensure any newly created columns are preserved
+        expected_columns = self.get_columns()
+        for col in expected_columns:
+            if col not in df.columns:
+                df[col] = None
+
+        return df
+
+    def _prepare_collection_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Prepare collection data for API submission"""
+        collection_data = {}
+
+        # Map common fields
+        field_mappings = {
+            "title": "title",
+            "description": "description",
+            "color": "color",
+            "view": "view",
+            "public": "public",
+            "sort": "sort",
+            "parent_id": "parent",
+            "parent.id": "parent",
+        }
+
+        for key, value in data.items():
+            if key in field_mappings:
+                api_key = field_mappings[key]
+                if api_key == "parent" and value:
+                    collection_data[api_key] = {"$id": int(value)}
+                elif key in ["public"] and value is not None:
+                    collection_data[api_key] = bool(value)
+                elif value is not None:
+                    collection_data[api_key] = value
+
+        return collection_data
+
+
+class TagsTable(APITable):
+    """The Raindrop.io Tags Table implementation"""
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        """
+        Pulls Raindrop.io tags data.
+
+        Parameters
+        ----------
+        query : ast.Select
+           Given SQL SELECT query
+
+        Returns
+        -------
+        pd.DataFrame
+            Raindrop.io tags with usage statistics
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        select_statement_parser = SELECTQueryParser(query, "tags", self.get_columns())
+        (
+            selected_columns,
+            where_conditions,
+            order_by_conditions,
+            result_limit,
+        ) = select_statement_parser.parse_query()
+
+        # Get tags data from API
+        tags_data = self.get_tags()
+
+        # Convert to DataFrame
+        if tags_data:
+            tags_df = pd.json_normalize(tags_data)
+            tags_df = self._normalize_tags_data(tags_df)
+        else:
+            # Create empty DataFrame with all expected columns
+            tags_df = pd.DataFrame(columns=self.get_columns())
+
+        # Ensure all expected columns exist (defensive check)
+        expected_columns = self.get_columns()
+        for col in expected_columns:
+            if col not in tags_df.columns:
+                logger.warning(f"Missing column after normalization: {col}, adding as None")
+                tags_df[col] = None
+
+        # Apply filtering and ordering using the executor
+        select_statement_executor = SELECTQueryExecutor(
+            tags_df, selected_columns, where_conditions, order_by_conditions
+        )
+        tags_df = select_statement_executor.execute_query()
+
+        # Apply limit if needed
+        if result_limit and len(tags_df) > result_limit:
+            tags_df = tags_df.head(result_limit)
+
+        return tags_df
+
+    def insert(self, query: ast.Insert) -> None:
+        """
+        Tags are typically created automatically when bookmarks are tagged.
+        Direct tag creation is not supported by the Raindrop.io API.
+
+        Parameters
+        ----------
+        query : ast.Insert
+           Given SQL INSERT query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        NotImplementedError
+            Direct tag creation is not supported
+        """
+        raise NotImplementedError(
+            "Direct tag creation is not supported by Raindrop.io API. "
+            "Tags are created automatically when bookmarks are tagged."
+        )
+
+    def update(self, query: ast.Update) -> None:
+        """
+        Tag updates are typically handled through bookmark updates.
+        Direct tag updates are not supported by the Raindrop.io API.
+
+        Parameters
+        ----------
+        query : ast.Update
+           Given SQL UPDATE query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        NotImplementedError
+            Direct tag updates are not supported
+        """
+        raise NotImplementedError(
+            "Direct tag updates are not supported by Raindrop.io API. Tag updates are handled through bookmark updates."
+        )
+
+    def delete(self, query: ast.Delete) -> None:
+        """
+        Tag deletion removes the tag from all bookmarks.
+        This operation is not supported by the Raindrop.io API.
+
+        Parameters
+        ----------
+        query : ast.Delete
+           Given SQL DELETE query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        NotImplementedError
+            Tag deletion is not supported
+        """
+        raise NotImplementedError(
+            "Tag deletion is not supported by Raindrop.io API. "
+            "Tags are removed automatically when no bookmarks use them."
+        )
+
+    def get_columns(self) -> List[str]:
+        """Get the column names for the tags table"""
+        return [
+            "_id",
+            "label",
+            "count",
+            "created",
+            "lastUpdate",
+        ]
+
+    def get_tags(self) -> List[Dict]:
+        """Get tags data"""
+        if not self.handler.connection:
+            self.handler.connect()
+
+        response = self.handler.connection.get_tags()
+        return response.get("items", [])
+
+    def _normalize_tags_data(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Normalize tags data for consistent column structure"""
+        if df.empty:
+            return df
+
+        # Convert dates
+        for date_col in ["created", "lastUpdate"]:
+            try:
+                if date_col in df.columns:
+                    df[date_col] = pd.to_datetime(df[date_col], errors="coerce")
+            except Exception as e:
+                logger.warning(f"Error processing date column {date_col}: {e}")
+
+        # Ensure ALL expected columns exist, even if empty
+        expected_columns = self.get_columns()
+        for col in expected_columns:
+            if col not in df.columns:
+                df[col] = None
+
+        return df
+
+
+class ParseTable(APITable):
+    """The Raindrop.io Parse Table implementation for URL metadata extraction"""
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        """
+        Parse URLs to extract metadata.
+
+        Parameters
+        ----------
+        query : ast.Select
+           Given SQL SELECT query
+
+        Returns
+        -------
+        pd.DataFrame
+            URL metadata from parsed URLs
+
+        Raises
+        ------
+        ValueError
+            If the query contains an unsupported condition
+        """
+        select_statement_parser = SELECTQueryParser(query, "parse", self.get_columns())
+        (
+            selected_columns,
+            where_conditions,
+            order_by_conditions,
+            result_limit,
+        ) = select_statement_parser.parse_query()
+
+        # Extract URLs to parse from WHERE conditions
+        urls_to_parse = []
+
+        for condition in where_conditions:
+            # Handle different condition formats
+            if isinstance(condition, list) and len(condition) >= 3:
+                op, column, value = condition[0], condition[1], condition[2]
+            elif hasattr(condition, "op") and hasattr(condition, "column"):
+                op = getattr(condition, "op", "=")
+                column = condition.column
+                value = getattr(condition, "value", None)
+            else:
+                # Skip malformed conditions
+                logger.warning(f"Skipping malformed condition: {condition}")
+                continue
+
+            if column == "url" and op == "=" and isinstance(value, str):
+                urls_to_parse.append(value)
+            elif column == "url" and op == "in" and isinstance(value, list):
+                urls_to_parse.extend(value)
+
+        if not urls_to_parse:
+            raise ValueError(
+                "Please specify URL(s) to parse using WHERE url = 'https://...' or WHERE url IN ('url1', 'url2')"
+            )
+
+        # Parse URLs and collect results
+        parsed_results = []
+
+        for url in urls_to_parse:
+            try:
+                response = self.handler.connection.parse_url(url)
+                if response.get("result") and response.get("item"):
+                    parsed_item = response["item"]
+                    parsed_item["parsed_url"] = url  # Add original URL for reference
+                    parsed_results.append(parsed_item)
+                else:
+                    logger.warning(f"Failed to parse URL: {url}")
+                    # Add empty result for failed parsing
+                    parsed_results.append(
+                        {
+                            "parsed_url": url,
+                            "title": None,
+                            "excerpt": None,
+                            "domain": None,
+                            "type": None,
+                            "cover": None,
+                            "error": "Failed to parse URL",
+                        }
+                    )
+            except Exception as e:
+                logger.error(f"Error parsing URL {url}: {e}")
+                # Add error result
+                parsed_results.append(
+                    {
+                        "parsed_url": url,
+                        "title": None,
+                        "excerpt": None,
+                        "domain": None,
+                        "type": None,
+                        "cover": None,
+                        "error": str(e),
+                    }
+                )
+
+        # Convert to DataFrame
+        if parsed_results:
+            parse_df = pd.json_normalize(parsed_results)
+            parse_df = self._normalize_parse_data(parse_df)
+        else:
+            # Create empty DataFrame with all expected columns
+            parse_df = pd.DataFrame(columns=self.get_columns())
+
+        # Ensure all expected columns exist (defensive check)
+        expected_columns = self.get_columns()
+        for col in expected_columns:
+            if col not in parse_df.columns:
+                logger.warning(f"Missing column after normalization: {col}, adding as None")
+                parse_df[col] = None
+
+        # Apply filtering and ordering using the executor
+        select_statement_executor = SELECTQueryExecutor(
+            parse_df,
+            selected_columns,
+            [],
+            order_by_conditions,  # No additional filtering needed
+        )
+        parse_df = select_statement_executor.execute_query()
+
+        # Apply limit if needed
+        if result_limit and len(parse_df) > result_limit:
+            parse_df = parse_df.head(result_limit)
+
+        return parse_df
+
+    def insert(self, query: ast.Insert) -> None:
+        """
+        URL parsing is a read-only operation.
+        Use INSERT on the raindrops table to create bookmarks from parsed URLs.
+
+        Parameters
+        ----------
+        query : ast.Insert
+           Given SQL INSERT query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        NotImplementedError
+            URL parsing is read-only
+        """
+        raise NotImplementedError(
+            "URL parsing is a read-only operation. "
+            "Use INSERT on the raindrops table to create bookmarks from parsed URLs."
+        )
+
+    def update(self, query: ast.Update) -> None:
+        """
+        URL parsing is a read-only operation.
+
+        Parameters
+        ----------
+        query : ast.Update
+           Given SQL UPDATE query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        NotImplementedError
+            URL parsing is read-only
+        """
+        raise NotImplementedError("URL parsing is a read-only operation. Cannot update parsed URL metadata.")
+
+    def delete(self, query: ast.Delete) -> None:
+        """
+        URL parsing is a read-only operation.
+
+        Parameters
+        ----------
+        query : ast.Delete
+           Given SQL DELETE query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        NotImplementedError
+            URL parsing is read-only
+        """
+        raise NotImplementedError("URL parsing is a read-only operation. Cannot delete parsed URL metadata.")
+
+    def get_columns(self) -> List[str]:
+        """Get the column names for the parse table"""
+        return [
+            "parsed_url",
+            "title",
+            "excerpt",
+            "domain",
+            "type",
+            "cover",
+            "media",
+            "lastUpdate",
+            "error",
+        ]
+
+    def _normalize_parse_data(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Normalize parsed URL data for consistent column structure"""
+        if df.empty:
+            return df
+
+        # Convert dates
+        for date_col in ["lastUpdate"]:
+            try:
+                if date_col in df.columns:
+                    df[date_col] = pd.to_datetime(df[date_col], errors="coerce")
+            except Exception as e:
+                logger.warning(f"Error processing date column {date_col}: {e}")
+
+        # Ensure ALL expected columns exist, even if empty
+        expected_columns = self.get_columns()
+        for col in expected_columns:
+            if col not in df.columns:
+                df[col] = None
+
+        return df
+
+
+class BulkOperationsTable(APITable):
+    """The Raindrop.io Bulk Operations Table implementation for bulk move, update, and delete operations"""
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        """
+        Bulk operations are not queryable. Use this table for bulk operations only.
+
+        Parameters
+        ----------
+        query : ast.Select
+           Given SQL SELECT query
+
+        Returns
+        -------
+        pd.DataFrame
+            Empty DataFrame with operation status information
+
+        Raises
+        ------
+        NotImplementedError
+            Bulk operations are not queryable
+        """
+        raise NotImplementedError(
+            "Bulk operations table is not queryable. Use INSERT, UPDATE, or DELETE operations on this table for bulk operations."
+        )
+
+    def insert(self, query: ast.Insert) -> None:
+        """
+        Bulk operations are initiated through UPDATE or DELETE operations, not INSERT.
+
+        Parameters
+        ----------
+        query : ast.Insert
+           Given SQL INSERT query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        NotImplementedError
+            Bulk operations use UPDATE/DELETE
+        """
+        raise NotImplementedError(
+            "Use UPDATE operations on the raindrops table for bulk updates, or DELETE operations for bulk deletions."
+        )
+
+    def update(self, query: ast.Update) -> None:
+        """
+        Perform bulk move operations between collections.
+
+        Parameters
+        ----------
+        query : ast.Update
+           Given SQL UPDATE query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        ValueError
+            If the query contains invalid conditions
+        """
+        update_statement_parser = UPDATEQueryParser(query)
+        values_to_update, where_conditions = update_statement_parser.parse_query()
+
+        # Check if this is a move operation (has collection_id in update values)
+        if "collection_id" not in values_to_update:
+            raise ValueError("Bulk operations table only supports collection moves. Use 'collection_id' in SET clause.")
+
+        target_collection_id = values_to_update["collection_id"]
+
+        # Extract conditions for the move operation
+        source_collection_id = None
+        raindrop_ids = []
+        search_query = None
+
+        for condition in where_conditions:
+            if condition.column == "source_collection_id":
+                source_collection_id = condition.value
+            elif condition.column in ["_id", "id"]:
+                if isinstance(condition.value, list):
+                    raindrop_ids.extend(condition.value)
+                else:
+                    raindrop_ids.append(condition.value)
+            elif condition.column in ["search", "title"]:
+                search_query = condition.value
+
+        # Validate that we have at least one condition
+        if not source_collection_id and not raindrop_ids and not search_query:
+            raise ValueError(
+                "Please specify source conditions using one of: source_collection_id = X, _id = Y, search = 'text'"
+            )
+
+        # Perform the bulk move operation
+        try:
+            result = self.handler.connection.move_raindrops_to_collection(
+                target_collection_id=target_collection_id,
+                source_collection_id=source_collection_id,
+                search=search_query,
+                ids=raindrop_ids if raindrop_ids else None,
+            )
+
+            if result.get("result"):
+                logger.info(f"Successfully moved raindrops to collection {target_collection_id}")
+            else:
+                logger.warning(f"Bulk move operation may have failed: {result}")
+
+        except Exception as e:
+            logger.error(f"Failed to perform bulk move operation: {e}")
+            raise
+
+    def delete(self, query: ast.Delete) -> None:
+        """
+        Bulk delete operations are handled by the raindrops table.
+        Use DELETE on the raindrops table for bulk deletions.
+
+        Parameters
+        ----------
+        query : ast.Delete
+           Given SQL DELETE query
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        NotImplementedError
+            Bulk operations use raindrops table
+        """
+        raise NotImplementedError("Use DELETE operations on the raindrops table for bulk deletions.")
+
+    def get_columns(self) -> List[str]:
+        """Get the column names for the bulk operations table"""
+        return [
+            "operation",
+            "status",
+            "affected_count",
+            "target_collection_id",
+            "source_collection_id",
+            "error",
+        ]
diff --git a/mindsdb/integrations/utilities/rag/pipelines/__init__.py b/mindsdb/integrations/handlers/raindrop_handler/requirements.txt
similarity index 100%
rename from mindsdb/integrations/utilities/rag/pipelines/__init__.py
rename to mindsdb/integrations/handlers/raindrop_handler/requirements.txt
diff --git a/mindsdb/integrations/handlers/raindrop_handler/tests/__init__.py b/mindsdb/integrations/handlers/raindrop_handler/tests/__init__.py
new file mode 100644
index 00000000000..dd46c4f54c3
--- /dev/null
+++ b/mindsdb/integrations/handlers/raindrop_handler/tests/__init__.py
@@ -0,0 +1 @@
+# Raindrop.io handler tests
diff --git a/mindsdb/integrations/handlers/raindrop_handler/tests/test_raindrop_handler.py b/mindsdb/integrations/handlers/raindrop_handler/tests/test_raindrop_handler.py
new file mode 100644
index 00000000000..131cbf7d0c5
--- /dev/null
+++ b/mindsdb/integrations/handlers/raindrop_handler/tests/test_raindrop_handler.py
@@ -0,0 +1,2068 @@
+import unittest
+from unittest.mock import Mock, patch
+import pandas as pd
+
+from mindsdb.integrations.handlers.raindrop_handler.raindrop_handler import RaindropHandler, RaindropAPIClient
+from mindsdb.integrations.handlers.raindrop_handler.raindrop_tables import (
+    RaindropsTable,
+    CollectionsTable,
+    TagsTable,
+    ParseTable,
+    BulkOperationsTable,
+)
+
+
+class TestRaindropHandler(unittest.TestCase):
+    """Test cases for RaindropHandler"""
+
+    def setUp(self):
+        self.handler = RaindropHandler("test_raindrop_handler")
+        self.handler.connection_data = {"api_key": "test_api_key"}
+
+    def test_init(self):
+        """Test handler initialization"""
+        self.assertEqual(self.handler.name, "test_raindrop_handler")
+        self.assertFalse(self.handler.is_connected)
+        self.assertIn("raindrops", self.handler._tables)
+        self.assertIn("bookmarks", self.handler._tables)
+        self.assertIn("collections", self.handler._tables)
+
+    @patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_handler.RaindropAPIClient")
+    def test_connect(self, mock_client):
+        """Test connection establishment"""
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+
+        result = self.handler.connect()
+
+        mock_client.assert_called_once_with("test_api_key")
+        self.assertEqual(result, mock_instance)
+        self.assertTrue(self.handler.is_connected)
+
+    def test_connect_missing_api_key(self):
+        """Test connection with missing API key"""
+        self.handler.connection_data = {}
+
+        with self.assertRaises(ValueError) as context:
+            self.handler.connect()
+
+        self.assertIn("API key is required", str(context.exception))
+
+    @patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_handler.RaindropAPIClient")
+    def test_check_connection_success(self, mock_client):
+        """Test successful connection check"""
+        mock_instance = Mock()
+        mock_instance.get_user_stats.return_value = {"result": True}
+        mock_client.return_value = mock_instance
+
+        result = self.handler.check_connection()
+
+        self.assertTrue(result.success)
+        self.assertTrue(self.handler.is_connected)
+
+    @patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_handler.RaindropAPIClient")
+    def test_check_connection_failure(self, mock_client):
+        """Test failed connection check"""
+        mock_instance = Mock()
+        mock_instance.get_user_stats.return_value = {"result": False}
+        mock_client.return_value = mock_instance
+
+        result = self.handler.check_connection()
+
+        self.assertFalse(result.success)
+        self.assertFalse(self.handler.is_connected)
+
+    @patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_handler.RaindropAPIClient")
+    def test_check_connection_exception(self, mock_client):
+        """Test connection check with exception"""
+        mock_instance = Mock()
+        mock_instance.get_user_stats.side_effect = Exception("Connection error")
+        mock_client.return_value = mock_instance
+
+        result = self.handler.check_connection()
+
+        self.assertFalse(result.success)
+        self.assertIn("Connection error", result.error_message)
+
+
+class TestRaindropAPIClient(unittest.TestCase):
+    """Test cases for RaindropAPIClient"""
+
+    def setUp(self):
+        self.client = RaindropAPIClient("test_api_key")
+
+    @patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_handler.requests")
+    def test_make_request_get(self, mock_requests):
+        """Test GET request"""
+        mock_response = Mock()
+        mock_response.json.return_value = {"result": True, "items": []}
+        mock_response.raise_for_status.return_value = None
+        mock_requests.request.return_value = mock_response
+
+        result = self.client._make_request("GET", "/user/stats")
+
+        mock_requests.request.assert_called_once_with(
+            method="GET",
+            url="https://api.raindrop.io/rest/v1/user/stats",
+            headers={"Authorization": "Bearer test_api_key", "Content-Type": "application/json"},
+            params=None,
+            json=None,
+        )
+        self.assertEqual(result, {"result": True, "items": []})
+
+    @patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_handler.requests.request")
+    def test_rate_limiting(self, mock_request):
+        """Test that rate limiting works correctly"""
+        import time
+
+        # Mock response
+        mock_response = Mock()
+        mock_response.json.return_value = {"result": True, "items": []}
+        mock_response.raise_for_status.return_value = None
+        mock_request.return_value = mock_response
+
+        # Reset request times to ensure clean state
+        self.client.request_times = []
+
+        # Make multiple rapid requests
+        start_time = time.time()
+        for i in range(3):
+            self.client._make_request("GET", "/user/stats")
+        end_time = time.time()
+
+        # Should take at least 1 second due to rate limiting (2 requests/second limit)
+        total_time = end_time - start_time
+        self.assertGreaterEqual(total_time, 1.0, "Rate limiting should add delays between requests")
+
+        # Should have tracked the requests (rate limiter may clean up old entries)
+        self.assertGreaterEqual(len(self.client.request_times), 1, "Should track at least the most recent request")
+
+    @patch.object(RaindropAPIClient, "_make_request")
+    def test_get_raindrops_optimized_pagination(self, mock_request):
+        """Test that get_raindrops optimizes page sizes based on LIMIT"""
+        # Mock response with items
+        mock_response = {"result": True, "items": [{"_id": 1, "title": "Test"}] * 5, "count": 5}
+        mock_request.return_value = mock_response
+
+        # Test small LIMIT - should use smaller page size
+        result = self.client.get_raindrops(max_results=5)
+        self.assertEqual(len(result["items"]), 5)
+
+        # Verify the request was made with optimized page size
+        args, kwargs = mock_request.call_args
+        self.assertEqual(kwargs["params"]["perpage"], 5, "Should use small page size for small LIMIT")
+
+        # Reset mock
+        mock_request.reset_mock()
+
+        # Test larger LIMIT - should use larger page size
+        result = self.client.get_raindrops(max_results=100)
+        args, kwargs = mock_request.call_args
+        self.assertEqual(kwargs["params"]["perpage"], 50, "Should use larger page size for bigger LIMIT")
+
+    @patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_handler.requests")
+    def test_make_request_post(self, mock_requests):
+        """Test POST request with data"""
+        mock_response = Mock()
+        mock_response.json.return_value = {"result": True, "item": {}}
+        mock_response.raise_for_status.return_value = None
+        mock_requests.request.return_value = mock_response
+
+        test_data = {"title": "Test"}
+        self.client._make_request("POST", "/raindrop", data=test_data)
+
+        mock_requests.request.assert_called_once_with(
+            method="POST",
+            url="https://api.raindrop.io/rest/v1/raindrop",
+            headers={"Authorization": "Bearer test_api_key", "Content-Type": "application/json"},
+            params=None,
+            json=test_data,
+        )
+
+    @patch.object(RaindropAPIClient, "_make_request")
+    def test_get_raindrops(self, mock_request):
+        """Test get_raindrops method"""
+        mock_request.return_value = {"result": True, "items": []}
+
+        self.client.get_raindrops(collection_id=123, search="test", page=1)
+
+        mock_request.assert_called_once_with(
+            "GET", "/raindrops/123", params={"page": 1, "perpage": 50, "search": "test"}
+        )
+
+    @patch.object(RaindropAPIClient, "_make_request")
+    def test_create_raindrop(self, mock_request):
+        """Test create_raindrop method"""
+        mock_request.return_value = {"result": True, "item": {}}
+
+        raindrop_data = {"link": "https://example.com", "title": "Test"}
+        self.client.create_raindrop(raindrop_data)
+
+        mock_request.assert_called_once_with("POST", "/raindrop", data=raindrop_data)
+
+    @patch.object(RaindropAPIClient, "_make_request")
+    def test_update_raindrop(self, mock_request):
+        """Test update_raindrop method"""
+        mock_request.return_value = {"result": True, "item": {}}
+
+        raindrop_data = {"title": "Updated Title"}
+        self.client.update_raindrop(123, raindrop_data)
+
+        mock_request.assert_called_once_with("PUT", "/raindrop/123", data=raindrop_data)
+
+    @patch.object(RaindropAPIClient, "_make_request")
+    def test_delete_raindrop(self, mock_request):
+        """Test delete_raindrop method"""
+        mock_request.return_value = {"result": True}
+
+        self.client.delete_raindrop(123)
+
+        mock_request.assert_called_once_with("DELETE", "/raindrop/123")
+
+    def test_make_request_invalid_endpoint(self):
+        """Test that invalid endpoints are rejected"""
+        with self.assertRaises(ValueError) as context:
+            self.client._make_request("GET", "/invalid/endpoint")
+
+        self.assertIn("Invalid endpoint", str(context.exception))
+        self.assertIn("Only Raindrop.io API endpoints are allowed", str(context.exception))
+
+    def test_make_request_path_traversal_attempt(self):
+        """Test that path traversal attempts are rejected"""
+        with self.assertRaises(ValueError) as context:
+            self.client._make_request("GET", "../../../etc/passwd")
+
+        self.assertIn("Invalid endpoint", str(context.exception))
+
+
+class TestRaindropsTable(unittest.TestCase):
+    """Test cases for RaindropsTable"""
+
+    def setUp(self):
+        self.handler = Mock()
+        self.handler.connection = Mock()
+        self.table = RaindropsTable(self.handler)
+
+    def test_apply_local_filters_greater_than(self):
+        """Test _apply_local_filters with greater than operator"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "created": "2024-01-01T00:00:00Z", "sort": 10},
+                {"_id": 2, "created": "2024-01-15T00:00:00Z", "sort": 20},
+                {"_id": 3, "created": "2024-01-30T00:00:00Z", "sort": 30},
+            ]
+        )
+
+        # Test date comparison
+        conditions = [[">", "created", "2024-01-15T00:00:00Z"]]
+        result = self.table._apply_local_filters(test_data.copy(), conditions)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result["_id"].iloc[0], 3)
+
+        # Test numeric comparison
+        conditions = [[">", "sort", 15]]
+        result = self.table._apply_local_filters(test_data.copy(), conditions)
+        self.assertEqual(len(result), 2)
+        self.assertListEqual(result["_id"].tolist(), [2, 3])
+
+    def test_apply_local_filters_less_than_equal(self):
+        """Test _apply_local_filters with less than or equal operator"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "sort": 10},
+                {"_id": 2, "sort": 20},
+                {"_id": 3, "sort": 30},
+            ]
+        )
+
+        conditions = [["<=", "sort", 20]]
+        result = self.table._apply_local_filters(test_data.copy(), conditions)
+        self.assertEqual(len(result), 2)
+        self.assertListEqual(result["_id"].tolist(), [1, 2])
+
+    def test_apply_local_filters_between(self):
+        """Test _apply_local_filters with BETWEEN operator"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "created": "2024-01-01T00:00:00Z"},
+                {"_id": 2, "created": "2024-01-15T00:00:00Z"},
+                {"_id": 3, "created": "2024-01-30T00:00:00Z"},
+            ]
+        )
+
+        conditions = [["between", "created", ("2024-01-05T00:00:00Z", "2024-01-25T00:00:00Z")]]
+        result = self.table._apply_local_filters(test_data.copy(), conditions)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result["_id"].iloc[0], 2)
+
+    def test_apply_local_filters_like(self):
+        """Test _apply_local_filters with LIKE operator"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "title": "Python Tutorial"},
+                {"_id": 2, "title": "JavaScript Guide"},
+                {"_id": 3, "title": "Python Best Practices"},
+            ]
+        )
+
+        conditions = [["like", "title", "%Python%"]]
+        result = self.table._apply_local_filters(test_data.copy(), conditions)
+        self.assertEqual(len(result), 2)
+        self.assertListEqual(result["_id"].tolist(), [1, 3])
+
+    def test_apply_local_filters_in(self):
+        """Test _apply_local_filters with IN operator"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "tags": "python,javascript"},
+                {"_id": 2, "tags": "java,ruby"},
+                {"_id": 3, "tags": "python,django"},
+            ]
+        )
+
+        conditions = [["in", "_id", [1, 3]]]
+        result = self.table._apply_local_filters(test_data.copy(), conditions)
+        self.assertEqual(len(result), 2)
+        self.assertListEqual(result["_id"].tolist(), [1, 3])
+
+    def test_apply_local_filters_important_flag(self):
+        """Test _apply_local_filters with important flag"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "important": True},
+                {"_id": 2, "important": False},
+                {"_id": 3, "important": True},
+            ]
+        )
+
+        conditions = [["=", "important", True]]
+        result = self.table._apply_local_filters(test_data.copy(), conditions)
+        self.assertEqual(len(result), 2)
+        self.assertListEqual(result["_id"].tolist(), [1, 3])
+
+    def test_apply_local_filters_multiple_conditions(self):
+        """Test _apply_local_filters with multiple conditions"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "important": True, "sort": 10},
+                {"_id": 2, "important": False, "sort": 20},
+                {"_id": 3, "important": True, "sort": 30},
+            ]
+        )
+
+        conditions = [["=", "important", True], [">", "sort", 15]]
+        result = self.table._apply_local_filters(test_data.copy(), conditions)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result["_id"].iloc[0], 3)
+
+    def test_apply_local_filters_unsupported_operator(self):
+        """Test _apply_local_filters with unsupported operator"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "title": "Test"},
+            ]
+        )
+
+        conditions = [["regex", "title", ".*"]]
+        with self.assertLogs(level="WARNING") as log:
+            result = self.table._apply_local_filters(test_data.copy(), conditions)
+            self.assertIn("Unsupported operator 'regex'", log.output[0])
+        self.assertEqual(len(result), 1)  # Original data should be returned
+
+    def test_apply_local_filters_missing_column(self):
+        """Test _apply_local_filters with missing column"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "title": "Test"},
+            ]
+        )
+
+        conditions = [["=", "missing_column", "value"]]
+        with self.assertLogs(level="WARNING") as log:
+            result = self.table._apply_local_filters(test_data.copy(), conditions)
+            self.assertIn("Column 'missing_column' not found", log.output[0])
+        self.assertEqual(len(result), 1)  # Original data should be returned
+
+    def test_apply_ordering(self):
+        """Test _apply_ordering method"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "sort": 30, "title": "Z Title"},
+                {"_id": 2, "sort": 10, "title": "A Title"},
+                {"_id": 3, "sort": 20, "title": "B Title"},
+            ]
+        )
+
+        # Mock order by conditions
+        order_conditions = [
+            type("MockOrder", (), {"column": "sort", "ascending": True})(),
+        ]
+
+        result = self.table._apply_ordering(test_data.copy(), order_conditions)
+        self.assertEqual(result["_id"].tolist(), [2, 3, 1])  # Sorted by sort ascending
+
+    def test_apply_ordering_descending(self):
+        """Test _apply_ordering method with descending order"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "sort": 10},
+                {"_id": 2, "sort": 30},
+                {"_id": 3, "sort": 20},
+            ]
+        )
+
+        # Mock order by conditions
+        order_conditions = [
+            type("MockOrder", (), {"column": "sort", "ascending": False})(),
+        ]
+
+        result = self.table._apply_ordering(test_data.copy(), order_conditions)
+        self.assertEqual(result["_id"].tolist(), [2, 3, 1])  # Sorted by sort descending
+
+    def test_apply_ordering_multiple_columns(self):
+        """Test _apply_ordering method with multiple columns"""
+        test_data = pd.DataFrame(
+            [
+                {"_id": 1, "sort": 10, "title": "B"},
+                {"_id": 2, "sort": 20, "title": "A"},
+                {"_id": 3, "sort": 10, "title": "A"},
+            ]
+        )
+
+        # Mock order by conditions
+        order_conditions = [
+            type("MockOrder", (), {"column": "sort", "ascending": True})(),
+            type("MockOrder", (), {"column": "title", "ascending": True})(),
+        ]
+
+        result = self.table._apply_ordering(test_data.copy(), order_conditions)
+        self.assertEqual(result["_id"].tolist(), [3, 1, 2])  # Sort by sort then title
+
+    def test_get_columns(self):
+        """Test get_columns method"""
+        columns = self.table.get_columns()
+
+        expected_columns = [
+            "_id",
+            "link",
+            "title",
+            "excerpt",
+            "note",
+            "type",
+            "cover",
+            "tags",
+            "important",
+            "reminder",
+            "removed",
+            "created",
+            "lastUpdate",
+            "domain",
+            "collection.id",
+            "collection.title",
+            "user.id",
+            "broken",
+            "cache",
+            "file.name",
+            "file.size",
+            "file.type",
+        ]
+
+        self.assertEqual(columns, expected_columns)
+
+    def test_normalize_raindrop_data(self):
+        """Test _normalize_raindrop_data method"""
+        test_data = pd.DataFrame(
+            [
+                {
+                    "_id": 123,
+                    "title": "Test",
+                    "collection": {"$id": 456, "title": "Test Collection"},
+                    "user": {"$id": 789},
+                    "file": {"name": "test.pdf", "size": 1024, "type": "pdf"},
+                    "tags": ["tag1", "tag2"],
+                    "created": "2024-01-01T00:00:00Z",
+                    "lastUpdate": "2024-01-02T00:00:00Z",
+                }
+            ]
+        )
+
+        result = self.table._normalize_raindrop_data(test_data)
+
+        self.assertEqual(result["collection.id"].iloc[0], 456)
+        self.assertEqual(result["collection.title"].iloc[0], "Test Collection")
+        self.assertEqual(result["user.id"].iloc[0], 789)
+        self.assertEqual(result["file.name"].iloc[0], "test.pdf")
+        self.assertEqual(result["file.size"].iloc[0], 1024)
+        self.assertEqual(result["file.type"].iloc[0], "pdf")
+        self.assertEqual(result["tags"].iloc[0], "tag1,tag2")
+
+    def test_prepare_raindrop_data(self):
+        """Test _prepare_raindrop_data method"""
+        input_data = {
+            "link": "https://example.com",
+            "title": "Test",
+            "collection_id": 123,
+            "tags": "tag1,tag2",
+            "important": True,
+        }
+
+        result = self.table._prepare_raindrop_data(input_data)
+
+        expected = {
+            "link": "https://example.com",
+            "title": "Test",
+            "collection": {"$id": 123},
+            "tags": ["tag1", "tag2"],
+            "important": True,
+        }
+
+        self.assertEqual(result, expected)
+
+    def test_prepare_raindrop_data_with_list_tags(self):
+        """Test _prepare_raindrop_data method with list tags"""
+        input_data = {"link": "https://example.com", "tags": ["tag1", "tag2"]}
+
+        result = self.table._prepare_raindrop_data(input_data)
+
+        self.assertEqual(result["tags"], ["tag1", "tag2"])
+
+    def test_normalize_raindrop_data_missing_columns(self):
+        """Test _normalize_raindrop_data method with missing columns"""
+        # Test with minimal data that might come from API (missing some nested fields)
+        test_data = pd.DataFrame(
+            [
+                {
+                    "_id": 123,
+                    "title": "Test Bookmark",
+                    "link": "https://example.com",
+                    "created": "2024-01-01T00:00:00Z",
+                    # Note: missing collection, user, file, tags fields
+                }
+            ]
+        )
+
+        result = self.table._normalize_raindrop_data(test_data)
+
+        # Check that all expected columns exist
+        expected_columns = self.table.get_columns()
+        for col in expected_columns:
+            self.assertIn(col, result.columns, f"Missing column: {col}")
+
+        # Check that missing nested fields are handled gracefully
+        self.assertIsNone(result["collection.id"].iloc[0])
+        self.assertIsNone(result["collection.title"].iloc[0])
+        self.assertIsNone(result["user.id"].iloc[0])
+        self.assertIsNone(result["file.name"].iloc[0])
+        self.assertIsNone(result["tags"].iloc[0])
+
+    def test_normalize_raindrop_data_empty_dataframe(self):
+        """Test _normalize_raindrop_data method with empty DataFrame"""
+        empty_df = pd.DataFrame()
+
+        result = self.table._normalize_raindrop_data(empty_df)
+
+        # Should return the same empty DataFrame
+        self.assertTrue(result.empty)
+
+    def test_select_with_empty_data(self):
+        """Test select method with empty data from API"""
+        # Mock empty response from API
+        self.handler.connection.get_raindrops.return_value = {"result": True, "items": []}
+
+        # Mock the SELECT query components
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+            patch(
+                "mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor"
+            ) as mock_executor,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = ([], [], [], None)
+            mock_parser.return_value = mock_parser_instance
+
+            # Mock executor to return DataFrame with columns (as it should after our fix)
+            mock_executor_instance = Mock()
+            empty_df_with_columns = pd.DataFrame(columns=self.table.get_columns())
+            mock_executor_instance.execute_query.return_value = empty_df_with_columns
+            mock_executor.return_value = mock_executor_instance
+
+            query = Mock()
+            result = self.table.select(query)
+
+            # Should return DataFrame with all expected columns
+            expected_columns = self.table.get_columns()
+            for col in expected_columns:
+                self.assertIn(col, result.columns, f"Missing column in empty result: {col}")
+
+            # Should be empty but have all columns
+            self.assertTrue(result.empty)
+            self.assertEqual(len(result.columns), len(expected_columns))
+
+    def test_select_optimized_for_limit(self):
+        """Test that SELECT with LIMIT uses optimized pagination"""
+        # Mock empty response from API (no items)
+        self.handler.connection.get_raindrops.return_value = {"result": True, "items": []}
+
+        # Mock the SELECT query components with LIMIT 3
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+            patch(
+                "mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor"
+            ) as mock_executor,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = ([], [], [], 3)  # LIMIT 3
+            mock_parser.return_value = mock_parser_instance
+
+            mock_executor_instance = Mock()
+            empty_df_with_columns = pd.DataFrame(columns=self.table.get_columns())
+            mock_executor_instance.execute_query.return_value = empty_df_with_columns
+            mock_executor.return_value = mock_executor_instance
+
+            query = Mock()
+            self.table.select(query)
+
+            # Verify that get_raindrops was called with max_results=3 for optimization
+            self.handler.connection.get_raindrops.assert_called_once()
+            args, kwargs = self.handler.connection.get_raindrops.call_args
+            self.assertEqual(kwargs.get("max_results"), 3, "Should pass LIMIT to API for optimization")
+
+    def test_normalize_raindrop_data_partial_nested_data(self):
+        """Test _normalize_raindrop_data with partial nested data"""
+        test_data = pd.DataFrame(
+            [
+                {
+                    "_id": 123,
+                    "title": "Test",
+                    "collection": {"$id": 456},  # Missing title
+                    "user": None,  # Explicitly None
+                    "tags": [],  # Empty list
+                    "created": "2024-01-01T00:00:00Z",
+                }
+            ]
+        )
+
+        result = self.table._normalize_raindrop_data(test_data)
+
+        # Check that partial data is handled correctly
+        self.assertEqual(result["collection.id"].iloc[0], 456)
+        self.assertIsNone(result["collection.title"].iloc[0])  # Missing field
+        self.assertIsNone(result["user.id"].iloc[0])  # None user
+        self.assertEqual(result["tags"].iloc[0], "")  # Empty list becomes empty string
+
+    @patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser")
+    @patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor")
+    def test_select_basic(self, mock_executor, mock_parser):
+        """Test basic select operation"""
+        # Mock parser
+        mock_parser_instance = Mock()
+        mock_parser_instance.parse_query.return_value = ([], [], [], None)
+        mock_parser.return_value = mock_parser_instance
+
+        # Mock executor
+        mock_executor_instance = Mock()
+        mock_executor_instance.execute_query.return_value = pd.DataFrame()
+        mock_executor.return_value = mock_executor_instance
+
+        # Mock API response
+        self.handler.connection.get_raindrops.return_value = {"result": True, "items": [{"_id": 123, "title": "Test"}]}
+
+        query = Mock()
+        result = self.table.select(query)
+
+        self.assertIsInstance(result, pd.DataFrame)
+
+    @patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.INSERTQueryParser")
+    def test_insert_single(self, mock_parser):
+        """Test single insert operation"""
+        mock_parser_instance = Mock()
+        mock_parser_instance.parse_query.return_value = {"link": "https://example.com", "title": "Test"}
+        mock_parser.return_value = mock_parser_instance
+
+        self.handler.connection.create_raindrop.return_value = {"result": True}
+
+        query = Mock()
+        self.table.insert(query)
+
+        self.handler.connection.create_raindrop.assert_called_once()
+
+    @patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.INSERTQueryParser")
+    def test_insert_multiple(self, mock_parser):
+        """Test multiple insert operation"""
+        mock_parser_instance = Mock()
+        mock_parser_instance.parse_query.return_value = [
+            {"link": "https://example1.com", "title": "Test1"},
+            {"link": "https://example2.com", "title": "Test2"},
+        ]
+        mock_parser.return_value = mock_parser_instance
+
+        self.handler.connection.create_multiple_raindrops.return_value = {"result": True}
+
+        query = Mock()
+        self.table.insert(query)
+
+        self.handler.connection.create_multiple_raindrops.assert_called_once()
+
+
+class TestCollectionsTable(unittest.TestCase):
+    """Test cases for CollectionsTable"""
+
+    def setUp(self):
+        self.handler = Mock()
+        self.handler.connection = Mock()
+        self.table = CollectionsTable(self.handler)
+
+    def test_get_columns(self):
+        """Test get_columns method"""
+        columns = self.table.get_columns()
+
+        expected_columns = [
+            "_id",
+            "title",
+            "description",
+            "color",
+            "view",
+            "public",
+            "sort",
+            "count",
+            "created",
+            "lastUpdate",
+            "expanded",
+            "parent.id",
+            "user.id",
+            "cover",
+            "access.level",
+            "access.draggable",
+        ]
+
+        self.assertEqual(columns, expected_columns)
+
+    def test_normalize_collection_data(self):
+        """Test _normalize_collection_data method"""
+        test_data = pd.DataFrame(
+            [
+                {
+                    "_id": 123,
+                    "title": "Test Collection",
+                    "parent": {"$id": 456},
+                    "user": {"$id": 789},
+                    "access": {"level": 4, "draggable": True},
+                    "cover": ["https://example.com/cover.jpg"],
+                    "created": "2024-01-01T00:00:00Z",
+                    "lastUpdate": "2024-01-02T00:00:00Z",
+                }
+            ]
+        )
+
+        result = self.table._normalize_collection_data(test_data)
+
+        self.assertEqual(result["parent.id"].iloc[0], 456)
+        self.assertEqual(result["user.id"].iloc[0], 789)
+        self.assertEqual(result["access.level"].iloc[0], 4)
+        self.assertEqual(result["access.draggable"].iloc[0], True)
+        self.assertEqual(result["cover"].iloc[0], "https://example.com/cover.jpg")
+
+    def test_normalize_collection_data_missing_columns(self):
+        """Test _normalize_collection_data method with missing columns"""
+        # Test with minimal data that might come from API (missing some nested fields)
+        test_data = pd.DataFrame(
+            [
+                {
+                    "_id": 123,
+                    "title": "Test Collection",
+                    "created": "2024-01-01T00:00:00Z",
+                    # Note: missing parent, user, access, cover fields
+                }
+            ]
+        )
+
+        result = self.table._normalize_collection_data(test_data)
+
+        # Check that all expected columns exist
+        expected_columns = self.table.get_columns()
+        for col in expected_columns:
+            self.assertIn(col, result.columns, f"Missing column: {col}")
+
+        # Check that missing nested fields are handled gracefully
+        self.assertIsNone(result["parent.id"].iloc[0])
+        self.assertIsNone(result["user.id"].iloc[0])
+        self.assertIsNone(result["access.level"].iloc[0])
+        self.assertIsNone(result["access.draggable"].iloc[0])
+        self.assertIsNone(result["cover"].iloc[0])
+
+    def test_normalize_collection_data_empty_dataframe(self):
+        """Test _normalize_collection_data method with empty DataFrame"""
+        empty_df = pd.DataFrame()
+
+        result = self.table._normalize_collection_data(empty_df)
+
+        # Should return the same empty DataFrame
+        self.assertTrue(result.empty)
+
+    def test_normalize_collection_data_partial_nested_data(self):
+        """Test _normalize_collection_data with partial nested data"""
+        test_data = pd.DataFrame(
+            [
+                {
+                    "_id": 123,
+                    "title": "Test Collection",
+                    "parent": {"$id": 456},  # Missing other parent fields
+                    "user": None,  # Explicitly None
+                    "access": {"level": 4},  # Missing draggable
+                    "created": "2024-01-01T00:00:00Z",
+                }
+            ]
+        )
+
+        result = self.table._normalize_collection_data(test_data)
+
+        # Check that partial data is handled correctly
+        self.assertEqual(result["parent.id"].iloc[0], 456)
+        self.assertIsNone(result["user.id"].iloc[0])  # None user
+        self.assertEqual(result["access.level"].iloc[0], 4)
+        self.assertIsNone(result["access.draggable"].iloc[0])  # Missing field
+
+    def test_prepare_collection_data(self):
+        """Test _prepare_collection_data method"""
+        input_data = {
+            "title": "Test Collection",
+            "description": "Test Description",
+            "color": "#FF0000",
+            "public": True,
+            "parent_id": 123,
+        }
+
+        result = self.table._prepare_collection_data(input_data)
+
+        expected = {
+            "title": "Test Collection",
+            "description": "Test Description",
+            "color": "#FF0000",
+            "public": True,
+            "parent": {"$id": 123},
+        }
+
+        self.assertEqual(result, expected)
+
+    def test_get_collections(self):
+        """Test get_collections method"""
+        # Mock get_collections to return both root and child collections
+        self.handler.connection.get_collections.return_value = {
+            "result": True,
+            "items": [{"_id": 123, "title": "Root Collection"}, {"_id": 456, "title": "Child Collection"}],
+        }
+
+        result = self.table.get_collections()
+
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result[0]["_id"], 123)
+        self.assertEqual(result[1]["_id"], 456)
+
+    def test_select_with_simple_filters(self):
+        """Test select method with simple WHERE clause conditions for collections"""
+        # Mock response with sample collection data
+        sample_data = [
+            {"_id": 123, "title": "Work Collection", "public": True},
+            {"_id": 456, "title": "Personal Collection", "public": False},
+        ]
+
+        # Mock the API responses
+        self.handler.connection.get_collections.return_value = {"result": True, "items": sample_data}
+
+        # Mock the SELECT query components
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+            patch(
+                "mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor"
+            ) as mock_executor,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                ["_id", "title"],  # selected_columns
+                [["=", "public", True]],  # where_conditions - corrected format
+                [],  # order_by_conditions
+                10,  # result_limit
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            mock_executor_instance = Mock()
+            filtered_df = pd.DataFrame([{"_id": 123, "title": "Work Collection", "public": True}])
+            mock_executor_instance.execute_query.return_value = filtered_df
+            mock_executor.return_value = mock_executor_instance
+
+            query = Mock()
+            result = self.table.select(query)
+
+            # Should filter to only public collections
+            self.assertEqual(len(result), 1)
+            self.assertEqual(result["_id"].iloc[0], 123)
+
+    def test_select_with_title_filter(self):
+        """Test select method with title filtering for collections"""
+        # Mock response with sample collection data
+        sample_data = [
+            {"_id": 123, "title": "Work Collection"},
+            {"_id": 456, "title": "Personal Collection"},
+        ]
+
+        # Mock the API responses
+        self.handler.connection.get_collections.return_value = {"result": True, "items": sample_data}
+
+        # Mock the SELECT query components
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+            patch(
+                "mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor"
+            ) as mock_executor,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                ["_id", "title"],  # selected_columns
+                [["like", "title", "%Work%"]],  # where_conditions - corrected format
+                [],  # order_by_conditions
+                None,  # result_limit
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            mock_executor_instance = Mock()
+            filtered_df = pd.DataFrame([{"_id": 123, "title": "Work Collection"}])
+            mock_executor_instance.execute_query.return_value = filtered_df
+            mock_executor.return_value = mock_executor_instance
+
+            query = Mock()
+            result = self.table.select(query)
+
+            # Should filter to collections with "Work" in title
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result["title"].iloc[0], "Work Collection")
+
+
+class TestTagsTable(unittest.TestCase):
+    """Test cases for TagsTable"""
+
+    def setUp(self):
+        self.handler = Mock()
+        self.handler.connection = Mock()
+        self.table = TagsTable(self.handler)
+
+    def test_get_columns(self):
+        """Test get_columns method"""
+        columns = self.table.get_columns()
+
+        expected_columns = [
+            "_id",
+            "label",
+            "count",
+            "created",
+            "lastUpdate",
+        ]
+
+        self.assertEqual(columns, expected_columns)
+
+    def test_select_basic(self):
+        """Test basic select operation"""
+        # Mock API response
+        sample_data = [
+            {
+                "_id": "tag1",
+                "label": "Python",
+                "count": 15,
+                "created": "2024-01-01T00:00:00Z",
+                "lastUpdate": "2024-01-01T00:00:00Z",
+            },
+            {
+                "_id": "tag2",
+                "label": "JavaScript",
+                "count": 8,
+                "created": "2024-02-01T00:00:00Z",
+                "lastUpdate": "2024-02-01T00:00:00Z",
+            },
+            {
+                "_id": "tag3",
+                "label": "Machine Learning",
+                "count": 3,
+                "created": "2024-03-01T00:00:00Z",
+                "lastUpdate": "2024-03-01T00:00:00Z",
+            },
+        ]
+
+        # Mock the SELECT query components
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+            patch(
+                "mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor"
+            ) as mock_executor,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = ([], [], [], None)
+            mock_parser.return_value = mock_parser_instance
+
+            mock_executor_instance = Mock()
+            # Create a DataFrame with the sample data for the executor to return
+            sample_df = pd.DataFrame(sample_data)
+            mock_executor_instance.execute_query.return_value = sample_df
+            mock_executor.return_value = mock_executor_instance
+
+            # Mock the handler connection's get_tags method
+            self.handler.connection.get_tags.return_value = {"items": sample_data}
+
+            query = Mock()
+            result = self.table.select(query)
+
+            # Should return DataFrame with all expected columns
+            expected_columns = self.table.get_columns()
+            for col in expected_columns:
+                self.assertIn(col, result.columns, f"Missing column: {col}")
+
+            # Should have the sample data
+            self.assertEqual(len(result), 3)
+            self.assertListEqual(result["label"].tolist(), ["Python", "JavaScript", "Machine Learning"])
+
+    def test_select_with_filters(self):
+        """Test select with filtering"""
+        sample_data = [
+            {
+                "_id": "tag1",
+                "label": "Python",
+                "count": 15,
+                "created": "2024-01-01T00:00:00Z",
+                "lastUpdate": "2024-01-01T00:00:00Z",
+            },
+            {
+                "_id": "tag2",
+                "label": "JavaScript",
+                "count": 8,
+                "created": "2024-02-01T00:00:00Z",
+                "lastUpdate": "2024-02-01T00:00:00Z",
+            },
+        ]
+
+        # Mock the SELECT query components
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+            patch(
+                "mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor"
+            ) as mock_executor,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                ["label", "count"],  # selected_columns
+                [["=", "count", 15]],  # where_conditions
+                [],  # order_by_conditions
+                None,  # result_limit
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            mock_executor_instance = Mock()
+            filtered_df = pd.DataFrame([{"label": "Python", "count": 15}])
+            mock_executor_instance.execute_query.return_value = filtered_df
+            mock_executor.return_value = mock_executor_instance
+
+            # Mock the handler connection's get_tags method
+            self.handler.connection.get_tags.return_value = {"items": sample_data}
+
+            query = Mock()
+            result = self.table.select(query)
+
+            # Should filter to tags with count = 15
+            self.assertEqual(len(result), 1)
+            self.assertEqual(result["label"].iloc[0], "Python")
+
+    def test_select_with_limit(self):
+        """Test select with LIMIT clause"""
+        sample_data = [
+            {
+                "_id": "tag1",
+                "label": "Python",
+                "count": 15,
+                "created": "2024-01-01T00:00:00Z",
+                "lastUpdate": "2024-01-01T00:00:00Z",
+            },
+            {
+                "_id": "tag2",
+                "label": "JavaScript",
+                "count": 8,
+                "created": "2024-02-01T00:00:00Z",
+                "lastUpdate": "2024-02-01T00:00:00Z",
+            },
+            {
+                "_id": "tag3",
+                "label": "Machine Learning",
+                "count": 3,
+                "created": "2024-03-01T00:00:00Z",
+                "lastUpdate": "2024-03-01T00:00:00Z",
+            },
+        ]
+
+        # Mock the SELECT query components
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+            patch(
+                "mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor"
+            ) as mock_executor,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                ["label", "count"],  # selected_columns
+                [],  # where_conditions
+                [],  # order_by_conditions
+                2,  # result_limit
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            mock_executor_instance = Mock()
+            limited_df = pd.DataFrame([{"label": "Python", "count": 15}, {"label": "JavaScript", "count": 8}])
+            mock_executor_instance.execute_query.return_value = limited_df
+            mock_executor.return_value = mock_executor_instance
+
+            # Mock the handler connection's get_tags method
+            self.handler.connection.get_tags.return_value = {"items": sample_data}
+
+            query = Mock()
+            result = self.table.select(query)
+
+            # Should limit to 2 results
+            self.assertEqual(len(result), 2)
+            self.assertListEqual(result["label"].tolist(), ["Python", "JavaScript"])
+
+    def test_insert_not_supported(self):
+        """Test that insert operation raises NotImplementedError"""
+        with self.assertRaises(NotImplementedError) as context:
+            query = Mock()
+            self.table.insert(query)
+
+        self.assertIn("Direct tag creation is not supported", str(context.exception))
+        self.assertIn("Raindrop.io API", str(context.exception))
+
+    def test_update_not_supported(self):
+        """Test that update operation raises NotImplementedError"""
+        with self.assertRaises(NotImplementedError) as context:
+            query = Mock()
+            self.table.update(query)
+
+        self.assertIn("Direct tag updates are not supported", str(context.exception))
+        self.assertIn("Raindrop.io API", str(context.exception))
+
+    def test_delete_not_supported(self):
+        """Test that delete operation raises NotImplementedError"""
+        with self.assertRaises(NotImplementedError) as context:
+            query = Mock()
+            self.table.delete(query)
+
+        self.assertIn("Tag deletion is not supported", str(context.exception))
+        self.assertIn("Raindrop.io API", str(context.exception))
+
+    def test_normalize_tags_data(self):
+        """Test _normalize_tags_data method"""
+        test_data = pd.DataFrame(
+            [
+                {
+                    "_id": "tag1",
+                    "label": "Python",
+                    "count": 15,
+                    "created": "2024-01-01T00:00:00Z",
+                    "lastUpdate": "2024-01-02T00:00:00Z",
+                }
+            ]
+        )
+
+        result = self.table._normalize_tags_data(test_data)
+
+        # Check that dates are converted to datetime
+        self.assertEqual(result["label"].iloc[0], "Python")
+        self.assertEqual(result["count"].iloc[0], 15)
+        # Note: Date conversion would require pandas datetime conversion, checking basic structure
+        self.assertIn("_id", result.columns)
+        self.assertIn("label", result.columns)
+        self.assertIn("count", result.columns)
+        self.assertIn("created", result.columns)
+        self.assertIn("lastUpdate", result.columns)
+
+    def test_normalize_tags_data_empty(self):
+        """Test _normalize_tags_data with empty DataFrame"""
+        empty_df = pd.DataFrame()
+
+        result = self.table._normalize_tags_data(empty_df)
+
+        # Should return the same empty DataFrame
+        self.assertTrue(result.empty)
+
+    def test_get_tags_calls_api(self):
+        """Test that get_tags calls the API correctly"""
+        expected_response = {
+            "items": [
+                {
+                    "_id": "tag1",
+                    "label": "Python",
+                    "count": 15,
+                    "created": "2024-01-01T00:00:00Z",
+                    "lastUpdate": "2024-01-01T00:00:00Z",
+                },
+                {
+                    "_id": "tag2",
+                    "label": "JavaScript",
+                    "count": 8,
+                    "created": "2024-02-01T00:00:00Z",
+                    "lastUpdate": "2024-02-01T00:00:00Z",
+                },
+            ]
+        }
+
+        self.handler.connection.get_tags.return_value = expected_response
+
+        result = self.table.get_tags()
+
+        # Should have called get_tags on the connection
+        self.handler.connection.get_tags.assert_called_once()
+        # Should return the items from the response
+        self.assertEqual(result, expected_response["items"])
+
+
+class TestParseTable(unittest.TestCase):
+    """Test cases for ParseTable"""
+
+    def setUp(self):
+        self.handler = Mock()
+        self.handler.connection = Mock()
+        self.table = ParseTable(self.handler)
+
+    def test_get_columns(self):
+        """Test get_columns method"""
+        columns = self.table.get_columns()
+
+        expected_columns = [
+            "parsed_url",
+            "title",
+            "excerpt",
+            "domain",
+            "type",
+            "cover",
+            "media",
+            "lastUpdate",
+            "error",
+        ]
+
+        self.assertEqual(columns, expected_columns)
+
+    def test_select_single_url(self):
+        """Test select with single URL to parse"""
+        # Mock API response
+        mock_parsed_data = {
+            "title": "Test Article",
+            "excerpt": "This is a test article excerpt",
+            "domain": "example.com",
+            "type": "article",
+            "cover": "https://example.com/cover.jpg",
+            "media": [{"link": "https://example.com/image.jpg"}],
+            "lastUpdate": "2024-01-01T00:00:00Z",
+        }
+
+        # Mock the SELECT query components
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+            patch(
+                "mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor"
+            ) as mock_executor,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                ["parsed_url", "title", "excerpt"],  # selected_columns
+                [["=", "url", "https://example.com/test"]],  # where_conditions
+                [],  # order_by_conditions
+                None,  # result_limit
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            mock_executor_instance = Mock()
+            # Create DataFrame with expected parsed data
+            expected_df = pd.DataFrame(
+                [
+                    {
+                        "parsed_url": "https://example.com/test",
+                        "title": "Test Article",
+                        "excerpt": "This is a test article excerpt",
+                        "domain": "example.com",
+                        "type": "article",
+                        "cover": "https://example.com/cover.jpg",
+                        "media": [{"link": "https://example.com/image.jpg"}],
+                        "lastUpdate": "2024-01-01T00:00:00Z",
+                        "error": None,
+                    }
+                ]
+            )
+            mock_executor_instance.execute_query.return_value = expected_df
+            mock_executor.return_value = mock_executor_instance
+
+            # Mock the API call
+            self.handler.connection.parse_url.return_value = {"result": True, "item": mock_parsed_data}
+
+            query = Mock()
+            result = self.table.select(query)
+
+            # Verify API was called with correct URL
+            self.handler.connection.parse_url.assert_called_once_with("https://example.com/test")
+
+            # Should return DataFrame with parsed data
+            self.assertEqual(len(result), 1)
+            self.assertEqual(result["parsed_url"].iloc[0], "https://example.com/test")
+            self.assertEqual(result["title"].iloc[0], "Test Article")
+
+    def test_select_multiple_urls(self):
+        """Test select with multiple URLs using IN operator"""
+        urls = ["https://example1.com", "https://example2.com"]
+
+        # Mock API responses for each URL
+        mock_responses = [
+            {
+                "result": True,
+                "item": {"title": "Article 1", "excerpt": "Excerpt 1", "domain": "example1.com", "type": "article"},
+            },
+            {
+                "result": True,
+                "item": {"title": "Article 2", "excerpt": "Excerpt 2", "domain": "example2.com", "type": "article"},
+            },
+        ]
+
+        # Mock the SELECT query components
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+            patch(
+                "mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor"
+            ) as mock_executor,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                ["parsed_url", "title"],  # selected_columns
+                [["in", "url", urls]],  # where_conditions
+                [],  # order_by_conditions
+                None,  # result_limit
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            mock_executor_instance = Mock()
+            expected_df = pd.DataFrame(
+                [
+                    {"parsed_url": "https://example1.com", "title": "Article 1", "error": None},
+                    {"parsed_url": "https://example2.com", "title": "Article 2", "error": None},
+                ]
+            )
+            mock_executor_instance.execute_query.return_value = expected_df
+            mock_executor.return_value = mock_executor_instance
+
+            # Mock the API calls
+            self.handler.connection.parse_url.side_effect = mock_responses
+
+            query = Mock()
+            result = self.table.select(query)
+
+            # Verify API was called for each URL
+            self.assertEqual(self.handler.connection.parse_url.call_count, 2)
+            calls = self.handler.connection.parse_url.call_args_list
+            self.assertEqual(calls[0][0][0], "https://example1.com")
+            self.assertEqual(calls[1][0][0], "https://example2.com")
+
+            # Should return DataFrame with both parsed URLs
+            self.assertEqual(len(result), 2)
+
+    def test_select_no_url_specified(self):
+        """Test select without URL specification raises error"""
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                ["parsed_url", "title"],  # selected_columns
+                [],  # where_conditions - no URL specified
+                [],  # order_by_conditions
+                None,  # result_limit
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            query = Mock()
+            with self.assertRaises(ValueError) as context:
+                self.table.select(query)
+
+            self.assertIn("Please specify URL(s) to parse", str(context.exception))
+            self.assertIn("WHERE url =", str(context.exception))
+
+    def test_select_api_error_handling(self):
+        """Test select handles API errors gracefully"""
+        # Mock the SELECT query components
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+            patch(
+                "mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor"
+            ) as mock_executor,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                ["parsed_url", "title", "error"],  # selected_columns
+                [["=", "url", "https://invalid-url.com"]],  # where_conditions
+                [],  # order_by_conditions
+                None,  # result_limit
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            mock_executor_instance = Mock()
+            expected_df = pd.DataFrame([{"parsed_url": "https://invalid-url.com", "title": None, "error": "API Error"}])
+            mock_executor_instance.execute_query.return_value = expected_df
+            mock_executor.return_value = mock_executor_instance
+
+            # Mock API to raise exception
+            self.handler.connection.parse_url.side_effect = Exception("API Error")
+
+            query = Mock()
+            result = self.table.select(query)
+
+            # Should handle error gracefully and return error info
+            self.assertEqual(len(result), 1)
+            self.assertEqual(result["parsed_url"].iloc[0], "https://invalid-url.com")
+            self.assertEqual(result["error"].iloc[0], "API Error")
+
+    def test_select_with_limit(self):
+        """Test select with LIMIT clause"""
+        urls = ["https://example1.com", "https://example2.com", "https://example3.com"]
+
+        # Mock the SELECT query components
+        with (
+            patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryParser") as mock_parser,
+            patch(
+                "mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.SELECTQueryExecutor"
+            ) as mock_executor,
+        ):
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                ["parsed_url", "title"],  # selected_columns
+                [["in", "url", urls]],  # where_conditions
+                [],  # order_by_conditions
+                2,  # result_limit
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            mock_executor_instance = Mock()
+            expected_df = pd.DataFrame(
+                [
+                    {"parsed_url": "https://example1.com", "title": "Article 1"},
+                    {"parsed_url": "https://example2.com", "title": "Article 2"},
+                ]
+            )
+            mock_executor_instance.execute_query.return_value = expected_df
+            mock_executor.return_value = mock_executor_instance
+
+            # Mock API calls
+            mock_responses = [
+                {"result": True, "item": {"title": "Article 1", "excerpt": "Excerpt 1"}},
+                {"result": True, "item": {"title": "Article 2", "excerpt": "Excerpt 2"}},
+                {"result": True, "item": {"title": "Article 3", "excerpt": "Excerpt 3"}},
+            ]
+            self.handler.connection.parse_url.side_effect = mock_responses
+
+            query = Mock()
+            result = self.table.select(query)
+
+            # Should limit to 2 results
+            self.assertEqual(len(result), 2)
+
+    def test_insert_not_supported(self):
+        """Test that insert operation raises NotImplementedError"""
+        with self.assertRaises(NotImplementedError) as context:
+            query = Mock()
+            self.table.insert(query)
+
+        self.assertIn("URL parsing is a read-only operation", str(context.exception))
+
+    def test_update_not_supported(self):
+        """Test that update operation raises NotImplementedError"""
+        with self.assertRaises(NotImplementedError) as context:
+            query = Mock()
+            self.table.update(query)
+
+        self.assertIn("URL parsing is a read-only operation", str(context.exception))
+
+    def test_delete_not_supported(self):
+        """Test that delete operation raises NotImplementedError"""
+        with self.assertRaises(NotImplementedError) as context:
+            query = Mock()
+            self.table.delete(query)
+
+        self.assertIn("URL parsing is a read-only operation", str(context.exception))
+
+    def test_normalize_parse_data(self):
+        """Test _normalize_parse_data method"""
+        test_data = pd.DataFrame(
+            [
+                {
+                    "parsed_url": "https://example.com",
+                    "title": "Test Article",
+                    "excerpt": "Test excerpt",
+                    "domain": "example.com",
+                    "lastUpdate": "2024-01-01T00:00:00Z",
+                }
+            ]
+        )
+
+        result = self.table._normalize_parse_data(test_data)
+
+        # Check that all expected columns exist
+        expected_columns = self.table.get_columns()
+        for col in expected_columns:
+            self.assertIn(col, result.columns, f"Missing column: {col}")
+
+        # Check specific values
+        self.assertEqual(result["parsed_url"].iloc[0], "https://example.com")
+        self.assertEqual(result["title"].iloc[0], "Test Article")
+
+    def test_normalize_parse_data_empty(self):
+        """Test _normalize_parse_data with empty DataFrame"""
+        empty_df = pd.DataFrame()
+
+        result = self.table._normalize_parse_data(empty_df)
+
+        # Should return the same empty DataFrame
+        self.assertTrue(result.empty)
+
+
+class TestBulkOperationsTable(unittest.TestCase):
+    """Test cases for BulkOperationsTable"""
+
+    def setUp(self):
+        self.handler = Mock()
+        self.handler.connection = Mock()
+        self.table = BulkOperationsTable(self.handler)
+
+    def test_get_columns(self):
+        """Test get_columns method"""
+        columns = self.table.get_columns()
+
+        expected_columns = [
+            "operation",
+            "status",
+            "affected_count",
+            "target_collection_id",
+            "source_collection_id",
+            "error",
+        ]
+
+        self.assertEqual(columns, expected_columns)
+
+    def test_select_not_supported(self):
+        """Test that select operation raises NotImplementedError"""
+        with self.assertRaises(NotImplementedError) as context:
+            query = Mock()
+            self.table.select(query)
+
+        self.assertIn("Bulk operations table is not queryable", str(context.exception))
+
+    def test_insert_not_supported(self):
+        """Test that insert operation raises NotImplementedError"""
+        with self.assertRaises(NotImplementedError) as context:
+            query = Mock()
+            self.table.insert(query)
+
+        self.assertIn("Use UPDATE operations on the raindrops table", str(context.exception))
+
+    def test_delete_not_supported(self):
+        """Test that delete operation raises NotImplementedError"""
+        with self.assertRaises(NotImplementedError) as context:
+            query = Mock()
+            self.table.delete(query)
+
+        self.assertIn("Use DELETE operations on the raindrops table", str(context.exception))
+
+    def test_update_bulk_move_by_collection(self):
+        """Test bulk move operation by source collection"""
+        # Mock the UPDATE query components
+        with patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.UPDATEQueryParser") as mock_parser:
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                {"collection_id": 456},  # values_to_update
+                [Mock(column="source_collection_id", value=123)],  # where_conditions
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            # Mock API call
+            self.handler.connection.move_raindrops_to_collection.return_value = {"result": True}
+
+            query = Mock()
+            self.table.update(query)
+
+            # Verify API was called with correct parameters
+            self.handler.connection.move_raindrops_to_collection.assert_called_once_with(
+                target_collection_id=456, source_collection_id=123, search=None, ids=None
+            )
+
+    def test_update_bulk_move_by_ids(self):
+        """Test bulk move operation by specific raindrop IDs"""
+        # Mock the UPDATE query components
+        with patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.UPDATEQueryParser") as mock_parser:
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                {"collection_id": 789},  # values_to_update
+                [Mock(column="_id", value=[1, 2, 3])],  # where_conditions
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            # Mock API call
+            self.handler.connection.move_raindrops_to_collection.return_value = {"result": True}
+
+            query = Mock()
+            self.table.update(query)
+
+            # Verify API was called with correct parameters
+            self.handler.connection.move_raindrops_to_collection.assert_called_once_with(
+                target_collection_id=789, source_collection_id=None, search=None, ids=[1, 2, 3]
+            )
+
+    def test_update_bulk_move_by_search(self):
+        """Test bulk move operation by search query"""
+        # Mock the UPDATE query components
+        with patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.UPDATEQueryParser") as mock_parser:
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                {"collection_id": 999},  # values_to_update
+                [Mock(column="search", value="python tutorial")],  # where_conditions
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            # Mock API call
+            self.handler.connection.move_raindrops_to_collection.return_value = {"result": True}
+
+            query = Mock()
+            self.table.update(query)
+
+            # Verify API was called with correct parameters
+            self.handler.connection.move_raindrops_to_collection.assert_called_once_with(
+                target_collection_id=999, source_collection_id=None, search="python tutorial", ids=None
+            )
+
+    def test_update_no_collection_id_error(self):
+        """Test update operation without collection_id raises error"""
+        # Mock the UPDATE query components
+        with patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.UPDATEQueryParser") as mock_parser:
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                {"title": "New Title"},  # values_to_update - no collection_id
+                [Mock(column="source_collection_id", value=123)],  # where_conditions
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            query = Mock()
+            with self.assertRaises(ValueError) as context:
+                self.table.update(query)
+
+            self.assertIn("Bulk operations table only supports collection moves", str(context.exception))
+
+    def test_update_no_conditions_error(self):
+        """Test update operation without any valid conditions raises error"""
+        # Mock the UPDATE query components
+        with patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.UPDATEQueryParser") as mock_parser:
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                {"collection_id": 456},  # values_to_update
+                [Mock(column="invalid_column", value="invalid")],  # where_conditions - no valid conditions
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            query = Mock()
+            with self.assertRaises(ValueError) as context:
+                self.table.update(query)
+
+            self.assertIn("Please specify source conditions", str(context.exception))
+
+    def test_update_api_error_handling(self):
+        """Test update operation handles API errors gracefully"""
+        # Mock the UPDATE query components
+        with patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_tables.UPDATEQueryParser") as mock_parser:
+            mock_parser_instance = Mock()
+            mock_parser_instance.parse_query.return_value = (
+                {"collection_id": 456},  # values_to_update
+                [Mock(column="source_collection_id", value=123)],  # where_conditions
+            )
+            mock_parser.return_value = mock_parser_instance
+
+            # Mock API to raise exception
+            self.handler.connection.move_raindrops_to_collection.side_effect = Exception("API Error")
+
+            query = Mock()
+            with self.assertRaises(Exception) as context:
+                self.table.update(query)
+
+            self.assertEqual(str(context.exception), "API Error")
+
+
+class TestAPICompatibility(unittest.TestCase):
+    """Test cases for Raindrop API compatibility"""
+
+    def setUp(self):
+        self.client = RaindropAPIClient("test_api_key")
+
+    def test_endpoint_format_compatibility(self):
+        """Test that all endpoints match official Raindrop API specification"""
+        # Test all endpoints used in the handler
+        test_endpoints = [
+            ("/user/stats", "GET"),
+            ("/raindrops/0", "GET"),
+            ("/raindrops/123", "GET"),
+            ("/raindrop/456", "GET"),
+            ("/raindrop", "POST"),
+            ("/raindrop/456", "PUT"),
+            ("/raindrop/456", "DELETE"),
+            ("/raindrops", "POST"),
+            ("/raindrops/123", "PUT"),
+            ("/raindrops/123", "DELETE"),
+            ("/collections", "GET"),
+            ("/collection/789", "GET"),
+            ("/collection", "POST"),
+            ("/collection/789", "PUT"),
+            ("/collection/789", "DELETE"),
+            ("/collections", "DELETE"),
+            ("/filters/0", "POST"),
+            ("/tags", "GET"),
+            ("/parse", "POST"),
+        ]
+
+        for endpoint, method in test_endpoints:
+            with self.subTest(endpoint=endpoint, method=method):
+                try:
+                    # This should not raise a ValueError for invalid endpoints
+                    self.client._make_request(method, endpoint)
+                except ValueError as e:
+                    if "Invalid endpoint" in str(e):
+                        self.fail(f"Endpoint {endpoint} not recognized as valid")
+                except Exception:
+                    # Other exceptions (like 401 unauthorized) are expected without real API
+                    pass
+
+    def test_parameter_names_compatibility(self):
+        """Test that parameter names match official API specification"""
+        # Test get_raindrops parameters
+        with patch.object(self.client, "_make_request") as mock_request:
+            mock_request.return_value = {"result": True, "items": []}
+
+            self.client.get_raindrops(collection_id=123, search="test query", sort="-created", page=1, per_page=25)
+
+            # Verify the call was made with correct parameter names
+            args, kwargs = mock_request.call_args
+            params = kwargs.get("params", {})
+
+            # Official API uses 'perpage' (lowercase, no underscore)
+            self.assertIn("perpage", params)
+            self.assertNotIn("per_page", params)
+            self.assertEqual(params["perpage"], 25)
+
+            # Other parameters should be lowercase
+            self.assertIn("page", params)
+            self.assertIn("search", params)
+            self.assertIn("sort", params)
+
+    def test_sort_parameter_format(self):
+        """Test that sort parameter format matches API specification"""
+        # Test ascending sort (just field name)
+        with patch.object(self.client, "_make_request") as mock_request:
+            mock_request.return_value = {"result": True, "items": []}
+
+            self.client.get_raindrops(sort="created")
+            args, kwargs = mock_request.call_args
+            params = kwargs.get("params", {})
+            self.assertEqual(params["sort"], "created")
+
+        # Test descending sort (field with minus prefix)
+        with patch.object(self.client, "_make_request") as mock_request:
+            mock_request.return_value = {"result": True, "items": []}
+
+            self.client.get_raindrops(sort="-created")
+            args, kwargs = mock_request.call_args
+            params = kwargs.get("params", {})
+            self.assertEqual(params["sort"], "-created")
+
+    def test_filters_endpoint_compatibility(self):
+        """Test /filters endpoint parameter compatibility"""
+        with patch.object(self.client, "_make_request") as mock_request:
+            mock_request.return_value = {"result": True, "items": []}
+
+            filters = {"search": "test query", "important": True, "tags": ["tag1", "tag2"], "page": 0, "perpage": 50}
+
+            self.client.get_raindrops_with_filters(collection_id=123, filters=filters)
+
+            # Verify the call was made correctly
+            args, kwargs = mock_request.call_args
+            self.assertEqual(args[0], "POST")  # Should be POST request
+            self.assertEqual(args[1], "/filters/123")  # Correct endpoint format
+            self.assertEqual(kwargs["data"], filters)  # Data should match filters
+
+    def test_bulk_operations_compatibility(self):
+        """Test bulk operations compatibility"""
+        with patch.object(self.client, "_make_request") as mock_request:
+            mock_request.return_value = {"result": True}
+
+            # Test move operation with search
+            self.client.move_raindrops_to_collection(
+                target_collection_id=456, source_collection_id=123, search="test query", ids=[1, 2, 3]
+            )
+
+            args, kwargs = mock_request.call_args
+            self.assertEqual(args[0], "PUT")
+            self.assertEqual(args[1], "/raindrops/123")  # Should use source collection
+
+            data = kwargs["data"]
+            expected_data = {"collection": {"$id": 456}, "search": "test query", "ids": [1, 2, 3]}
+            self.assertEqual(data, expected_data)
+
+        # Test move operation without source collection (uses collection 0)
+        with patch.object(self.client, "_make_request") as mock_request:
+            mock_request.return_value = {"result": True}
+
+            self.client.move_raindrops_to_collection(target_collection_id=456, search="test query")
+
+            args, kwargs = mock_request.call_args
+            self.assertEqual(args[1], "/raindrops/0")  # Should default to collection 0
+
+    def test_response_format_expectations(self):
+        """Test that response format expectations match API"""
+        # Test successful response format
+        with patch.object(self.client, "_make_request") as mock_request:
+            mock_request.return_value = {
+                "result": True,
+                "items": [{"_id": 123, "title": "Test Bookmark"}, {"_id": 456, "title": "Another Bookmark"}],
+                "count": 2,
+            }
+
+            response = self.client.get_collections()
+
+            # Verify response structure matches what our code expects
+            self.assertIn("result", response)
+            self.assertIn("items", response)
+            self.assertEqual(response["result"], True)
+            self.assertEqual(len(response["items"]), 2)
+
+    def test_error_handling_compatibility(self):
+        """Test error handling matches API error formats"""
+        with patch.object(self.client, "_make_request") as mock_request:
+            # Simulate API error response
+            mock_request.side_effect = Exception("Raindrop API error: Invalid collection ID")
+
+            with self.assertRaises(Exception) as context:
+                self.client.get_collection(999)
+
+            self.assertIn("Raindrop API error", str(context.exception))
+
+    def test_rate_limiting_compatibility(self):
+        """Test rate limiting implementation matches API limits"""
+        # Raindrop API allows 120 requests per minute
+        self.assertEqual(self.client.rate_limit_per_second, 2)  # 120/60 = 2 per second
+
+        # Test that rate limiting tracks requests properly
+        # Reset request times to ensure clean state
+        self.client.request_times = []
+
+        # Test the rate limiting method directly
+        self.client._apply_rate_limit()
+        self.assertEqual(len(self.client.request_times), 1)
+
+        # Test rate limit configuration
+        self.assertEqual(self.client.rate_limit_per_second, 2)
+        self.assertIsInstance(self.client.request_times, list)
+
+    def test_authentication_header_format(self):
+        """Test authentication header format matches API requirements"""
+        # Raindrop API uses Bearer token authentication
+        expected_auth = f"Bearer {self.client.api_key}"
+        self.assertEqual(self.client.headers["Authorization"], expected_auth)
+        self.assertEqual(self.client.headers["Content-Type"], "application/json")
+
+    def test_collections_endpoint_fix(self):
+        """Test that collections endpoint works correctly without children endpoint"""
+        # Mock the get_collections to return all collections
+        self.client._make_request = Mock(
+            return_value={
+                "result": True,
+                "items": [
+                    {"_id": 123, "title": "Root Collection"},
+                    {"_id": 456, "title": "Child Collection", "parent": {"$id": 123}},
+                ],
+            }
+        )
+
+        # Test that get_collections works without calling children endpoint
+        response = self.client.get_collections()
+
+        # Verify the call was made correctly
+        self.client._make_request.assert_called_once_with("GET", "/collections")
+
+        # Verify response structure
+        self.assertIn("result", response)
+        self.assertIn("items", response)
+        self.assertEqual(len(response["items"]), 2)
+
+    def test_collections_table_integration(self):
+        """Test that collections table works correctly with the fix"""
+        # Mock handler and connection
+        mock_handler = Mock()
+        mock_connection = Mock()
+        mock_handler.connection = mock_connection
+
+        # Mock get_collections to return all collections
+        mock_connection.get_collections.return_value = {
+            "items": [
+                {"_id": 123, "title": "Root Collection"},
+                {"_id": 456, "title": "Child Collection", "parent": {"$id": 123}},
+            ]
+        }
+
+        # Create collections table and test get_collections method
+        collections_table = CollectionsTable(mock_handler)
+        result = collections_table.get_collections()
+
+        # Verify that get_collections was called (not get_child_collections)
+        mock_connection.get_collections.assert_called_once()
+
+        # Verify that get_child_collections was NOT called
+        mock_connection.get_child_collections.assert_not_called()
+
+        # Verify result
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result[0]["_id"], 123)
+        self.assertEqual(result[1]["_id"], 456)
+
+
+class TestSearchOptimizations(unittest.TestCase):
+    """Test cases for enhanced search capabilities"""
+
+    def setUp(self):
+        self.table = RaindropsTable(None)
+
+    def test_enhanced_search_parsing_single_field(self):
+        """Test enhanced search parsing with single field search"""
+        conditions = [["=", "title", "Python Tutorial"]]
+
+        parsed = self.table._parse_where_conditions(conditions)
+
+        # Should convert to API search
+        self.assertEqual(parsed["search"], "title:Python Tutorial")
+        self.assertEqual(len(parsed["api_supported"]), 1)
+        self.assertEqual(len(parsed["local_filters"]), 0)
+
+    def test_enhanced_search_parsing_multiple_fields(self):
+        """Test enhanced search parsing with multiple field searches"""
+        conditions = [["=", "title", "Python"], ["=", "excerpt", "Tutorial"], ["=", "note", "Advanced"]]
+
+        parsed = self.table._parse_where_conditions(conditions)
+
+        # Should combine into complex search query
+        expected_search = "(title:Python AND excerpt:Tutorial AND note:Advanced)"
+        self.assertEqual(parsed["search"], expected_search)
+        self.assertEqual(len(parsed["api_supported"]), 3)
+        self.assertEqual(len(parsed["local_filters"]), 0)
+
+    def test_enhanced_search_like_optimization(self):
+        """Test LIKE pattern optimization to API search"""
+        conditions = [["like", "title", "%python%"], ["like", "excerpt", "%tutorial%"]]
+
+        parsed = self.table._parse_where_conditions(conditions)
+
+        # Should convert LIKE patterns to API search
+        self.assertIn("title:python", parsed["search"])
+        self.assertIn("excerpt:tutorial", parsed["search"])
+        self.assertEqual(len(parsed["api_supported"]), 2)
+        self.assertEqual(len(parsed["local_filters"]), 0)
+
+    def test_enhanced_search_mixed_conditions(self):
+        """Test mixed search conditions (API and local)"""
+        conditions = [
+            ["=", "title", "Python"],  # Should be optimized to API
+            ["=", "important", True],  # Should remain local
+            ["like", "tags", "%web%"],  # Should be optimized to API
+        ]
+
+        parsed = self.table._parse_where_conditions(conditions)
+
+        # Should have both API search and local filters
+        self.assertIsNotNone(parsed["search"])
+        self.assertIn("title:Python", parsed["search"])
+        self.assertIn("tag:web", parsed["search"])
+        self.assertEqual(len(parsed["local_filters"]), 1)  # important flag
+
+    def test_like_pattern_not_optimized_complex(self):
+        """Test that complex LIKE patterns are not optimized"""
+        conditions = [
+            ["like", "title", "python%"],  # Only starts with %, not optimized
+            ["like", "title", "%p%t%"],  # Contains regex chars, not optimized
+            ["like", "title", "%ab%"],  # Too short, not optimized
+        ]
+
+        parsed = self.table._parse_where_conditions(conditions)
+
+        # Should keep complex patterns as local filters
+        self.assertIsNone(parsed["search"])
+        self.assertEqual(len(parsed["local_filters"]), 3)
+
+    def test_like_pattern_optimized_simple(self):
+        """Test that simple LIKE patterns are optimized"""
+        conditions = [
+            ["like", "title", "%python%"],  # Should be optimized
+            ["like", "excerpt", "%tutorial%"],  # Should be optimized
+            ["like", "note", "%advanced%"],  # Should be optimized
+        ]
+
+        parsed = self.table._parse_where_conditions(conditions)
+
+        # Should convert to API search
+        self.assertIsNotNone(parsed["search"])
+        self.assertIn("title:python", parsed["search"])
+        self.assertIn("excerpt:tutorial", parsed["search"])
+        self.assertIn("note:advanced", parsed["search"])
+        self.assertEqual(len(parsed["api_supported"]), 3)
+        self.assertEqual(len(parsed["local_filters"]), 0)
+
+    def test_existing_search_not_overridden(self):
+        """Test that existing search conditions are not overridden by optimizations"""
+        conditions = [
+            ["=", "search", "original query"],
+            ["=", "title", "Python"],  # This should not override the search
+        ]
+
+        parsed = self.table._parse_where_conditions(conditions)
+
+        # Should keep original search
+        self.assertEqual(parsed["search"], "original query")
+        self.assertEqual(len(parsed["api_supported"]), 2)
+
+    def test_is_search_condition_detection(self):
+        """Test search condition detection logic"""
+        # Should detect search conditions
+        self.assertTrue(self.table._is_search_condition("title", "="))
+        self.assertTrue(self.table._is_search_condition("search", "="))
+        self.assertTrue(self.table._is_search_condition("excerpt", "like"))
+        self.assertTrue(self.table._is_search_condition("tags", "like"))
+
+        # Should not detect non-search conditions
+        self.assertFalse(self.table._is_search_condition("created", ">"))
+        self.assertFalse(self.table._is_search_condition("_id", "="))
+        self.assertFalse(self.table._is_search_condition("collection_id", "="))
+
+    def test_can_use_api_search_for_like(self):
+        """Test LIKE pattern optimization detection"""
+        # Should optimize simple patterns
+        self.assertTrue(self.table._can_use_api_search_for_like("title", "%python%"))
+        self.assertTrue(self.table._can_use_api_search_for_like("excerpt", "%tutorial%"))
+
+        # Should not optimize complex patterns
+        self.assertFalse(self.table._can_use_api_search_for_like("title", "python%"))
+        self.assertFalse(self.table._can_use_api_search_for_like("title", "%p%t%"))
+        self.assertFalse(self.table._can_use_api_search_for_like("title", "%ab%"))
+        self.assertFalse(self.table._can_use_api_search_for_like("title", "%test*ing%"))
+
+    def test_convert_like_to_api_search(self):
+        """Test LIKE to API search conversion"""
+        # Should convert properly
+        self.assertEqual(self.table._convert_like_to_api_search("title", "%python%"), "title:python")
+        self.assertEqual(self.table._convert_like_to_api_search("excerpt", "%tutorial%"), "excerpt:tutorial")
+        self.assertEqual(self.table._convert_like_to_api_search("note", "%advanced%"), "note:advanced")
+        self.assertEqual(self.table._convert_like_to_api_search("tags", "%web%"), "tag:web")
+
+        # Should handle non-string values
+        self.assertIsNone(self.table._convert_like_to_api_search("title", 123))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/mindsdb/integrations/handlers/raindrop_handler/tests/test_raindrop_integration.py b/mindsdb/integrations/handlers/raindrop_handler/tests/test_raindrop_integration.py
new file mode 100644
index 00000000000..ee8fd863c21
--- /dev/null
+++ b/mindsdb/integrations/handlers/raindrop_handler/tests/test_raindrop_integration.py
@@ -0,0 +1,178 @@
+import unittest
+import os
+import pandas as pd
+from mindsdb.integrations.handlers.raindrop_handler.raindrop_handler import RaindropHandler
+
+
+class TestRaindropHandlerIntegration(unittest.TestCase):
+    """Integration tests for RaindropHandler (requires valid API key)"""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up the test environment"""
+        cls.api_key = os.environ.get("RAINDROP_API_KEY")
+        if not cls.api_key:
+            raise unittest.SkipTest("RAINDROP_API_KEY environment variable not set")
+
+        cls.handler = RaindropHandler("test_raindrop_handler")
+        cls.handler.connection_data = {"api_key": cls.api_key}
+
+    def test_check_connection(self):
+        """Test that we can connect to the Raindrop.io API"""
+        response = self.handler.check_connection()
+        self.assertTrue(response.success, f"Connection failed: {response.error_message}")
+
+    def test_get_tables(self):
+        """Test that tables are properly registered"""
+        tables = self.handler.get_tables()
+        table_names = [table.data[0] for table in tables.data]
+
+        self.assertIn("raindrops", table_names)
+        self.assertIn("bookmarks", table_names)
+        self.assertIn("collections", table_names)
+
+    def test_raindrops_table_select(self):
+        """Test selecting from raindrops table"""
+        # Test basic select
+        query = "SELECT * FROM raindrops LIMIT 5"
+        result = self.handler.native_query(query)
+        self.assertTrue(result.success, f"Query failed: {result.error_message}")
+
+        # Check that we get a DataFrame
+        if hasattr(result, "data_frame") and result.data_frame is not None:
+            self.assertIsInstance(result.data_frame, pd.DataFrame)
+
+    def test_collections_table_select(self):
+        """Test selecting from collections table"""
+        query = "SELECT * FROM collections LIMIT 5"
+        result = self.handler.native_query(query)
+        self.assertTrue(result.success, f"Query failed: {result.error_message}")
+
+        # Check that we get a DataFrame
+        if hasattr(result, "data_frame") and result.data_frame is not None:
+            self.assertIsInstance(result.data_frame, pd.DataFrame)
+
+    def test_raindrops_table_columns(self):
+        """Test that raindrops table has expected columns"""
+        raindrops_table = self.handler.get_table("raindrops")
+        columns = raindrops_table.get_columns()
+
+        expected_columns = [
+            "_id",
+            "link",
+            "title",
+            "excerpt",
+            "note",
+            "type",
+            "cover",
+            "tags",
+            "important",
+            "reminder",
+            "removed",
+            "created",
+            "lastUpdate",
+            "domain",
+            "collection.id",
+            "collection.title",
+            "user.id",
+            "broken",
+            "cache",
+            "file.name",
+            "file.size",
+            "file.type",
+        ]
+
+        for col in expected_columns:
+            self.assertIn(col, columns, f"Column {col} not found in raindrops table")
+
+    def test_collections_table_columns(self):
+        """Test that collections table has expected columns"""
+        collections_table = self.handler.get_table("collections")
+        columns = collections_table.get_columns()
+
+        expected_columns = [
+            "_id",
+            "title",
+            "description",
+            "color",
+            "view",
+            "public",
+            "sort",
+            "count",
+            "created",
+            "lastUpdate",
+            "expanded",
+            "parent.id",
+            "user.id",
+            "cover",
+            "access.level",
+            "access.draggable",
+        ]
+
+        for col in expected_columns:
+            self.assertIn(col, columns, f"Column {col} not found in collections table")
+
+    def test_create_and_delete_bookmark(self):
+        """Test creating and deleting a bookmark (if API key has write permissions)"""
+        try:
+            # Create a test bookmark
+            insert_query = """
+            INSERT INTO raindrops (link, title, note, tags) 
+            VALUES ('https://example.com/test', 'Test Bookmark', 'Test note', 'test,automated')
+            """
+            result = self.handler.native_query(insert_query)
+
+            if not result.success:
+                # Skip if we don't have write permissions
+                self.skipTest(f"Cannot create bookmarks: {result.error_message}")
+
+            # Try to find the bookmark we just created
+            select_query = "SELECT * FROM raindrops WHERE title = 'Test Bookmark' LIMIT 1"
+            result = self.handler.native_query(select_query)
+            self.assertTrue(result.success)
+
+            if hasattr(result, "data_frame") and result.data_frame is not None and not result.data_frame.empty:
+                bookmark_id = result.data_frame["_id"].iloc[0]
+
+                # Delete the test bookmark
+                delete_query = f"DELETE FROM raindrops WHERE _id = {bookmark_id}"
+                result = self.handler.native_query(delete_query)
+                self.assertTrue(result.success)
+
+        except Exception as e:
+            self.fail(f"Create/delete test failed: {e}")
+
+    def test_create_and_delete_collection(self):
+        """Test creating and deleting a collection (if API key has write permissions)"""
+        try:
+            # Create a test collection
+            insert_query = """
+            INSERT INTO collections (title, description, color) 
+            VALUES ('Test Collection', 'Automated test collection', '#FF0000')
+            """
+            result = self.handler.native_query(insert_query)
+
+            if not result.success:
+                # Skip if we don't have write permissions
+                self.skipTest(f"Cannot create collections: {result.error_message}")
+
+            # Try to find the collection we just created
+            select_query = "SELECT * FROM collections WHERE title = 'Test Collection' LIMIT 1"
+            result = self.handler.native_query(select_query)
+            self.assertTrue(result.success)
+
+            if hasattr(result, "data_frame") and result.data_frame is not None and not result.data_frame.empty:
+                collection_id = result.data_frame["_id"].iloc[0]
+
+                # Delete the test collection
+                delete_query = f"DELETE FROM collections WHERE _id = {collection_id}"
+                result = self.handler.native_query(delete_query)
+                self.assertTrue(result.success)
+
+        except Exception as e:
+            self.fail(f"Create/delete collection test failed: {e}")
+
+
+if __name__ == "__main__":
+    # Run integration tests only if API key is available
+    unittest.main()
diff --git a/mindsdb/integrations/handlers/raindrop_handler/verify_implementation.py b/mindsdb/integrations/handlers/raindrop_handler/verify_implementation.py
new file mode 100644
index 00000000000..f220ba740c5
--- /dev/null
+++ b/mindsdb/integrations/handlers/raindrop_handler/verify_implementation.py
@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+
+"""
+Verification script for the Raindrop.io handler implementation.
+This script checks all the key functionality without requiring a real API key.
+
+Recent improvements:
+- Uses logging instead of print statements for better integration with MindsDB logging
+- Tests robustness of data normalization with missing columns
+- Validates error handling for various edge cases
+- Implements rate limiting to prevent API quota exhaustion
+- Optimizes pagination for small LIMIT queries
+"""
+
+import sys
+import logging
+from unittest.mock import Mock, patch
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def test_handler_loading():
+    """Test that the handler can be loaded and instantiated"""
+    try:
+        from mindsdb.integrations.handlers.raindrop_handler import Handler, name, type, title, connection_args
+
+        logger.info("[PASS] Handler module loaded successfully")
+        logger.info(f"  Name: {name}")
+        logger.info(f"  Type: {type}")
+        logger.info(f"  Title: {title}")
+        logger.info(f"  Connection args: {list(connection_args.keys())}")
+
+        # Test instantiation
+        handler = Handler("test_handler")
+        logger.info("[PASS] Handler instantiated successfully")
+        logger.info(f"  Tables: {list(handler._tables.keys())}")
+
+        return True
+    except Exception as e:
+        logger.error(f"[FAIL] Handler loading failed: {e}")
+        return False
+
+
+def test_api_client():
+    """Test the API client functionality"""
+    try:
+        from mindsdb.integrations.handlers.raindrop_handler.raindrop_handler import RaindropAPIClient
+
+        client = RaindropAPIClient("test_key")
+        logger.info("[PASS] API client instantiated successfully")
+        logger.info(f"  Base URL: {client.base_url}")
+        logger.info(f"  Headers configured: {'Authorization' in client.headers}")
+
+        return True
+    except Exception as e:
+        logger.error(f"[FAIL] API client test failed: {e}")
+        return False
+
+
+def test_table_functionality():
+    """Test table functionality with mocked data"""
+    try:
+        from mindsdb.integrations.handlers.raindrop_handler.raindrop_tables import RaindropsTable, CollectionsTable
+        import pandas as pd
+
+        # Test RaindropsTable
+        handler_mock = Mock()
+        raindrops_table = RaindropsTable(handler_mock)
+
+        columns = raindrops_table.get_columns()
+        logger.info(f"[PASS] RaindropsTable columns: {len(columns)} columns")
+
+        # Test data normalization
+        test_data = pd.DataFrame(
+            [
+                {
+                    "_id": 123,
+                    "title": "Test",
+                    "collection": {"$id": 456, "title": "Test Collection"},
+                    "tags": ["tag1", "tag2"],
+                    "created": "2024-01-01T00:00:00Z",
+                }
+            ]
+        )
+
+        raindrops_table._normalize_raindrop_data(test_data)
+        logger.info("[PASS] RaindropsTable data normalization works")
+
+        # Test data preparation
+        raindrops_table._prepare_raindrop_data(
+            {"link": "https://example.com", "title": "Test", "tags": "tag1,tag2", "collection_id": 123}
+        )
+        logger.info("[PASS] RaindropsTable data preparation works")
+
+        # Test CollectionsTable
+        collections_table = CollectionsTable(handler_mock)
+        columns = collections_table.get_columns()
+        logger.info(f"[PASS] CollectionsTable columns: {len(columns)} columns")
+
+        return True
+    except Exception as e:
+        logger.error(f"[FAIL] Table functionality test failed: {e}")
+        return False
+
+
+def test_connection_handling():
+    """Test connection handling"""
+    try:
+        from mindsdb.integrations.handlers.raindrop_handler import Handler
+
+        # Test with missing API key
+        handler = Handler("test")
+        try:
+            handler.connect()
+            logger.error("[FAIL] Should have failed with missing API key")
+            return False
+        except ValueError as e:
+            if "API key is required" in str(e):
+                logger.info("[PASS] Properly validates missing API key")
+            else:
+                logger.error(f"[FAIL] Unexpected error: {e}")
+                return False
+
+        # Test with API key
+        handler.connection_data = {"api_key": "test_key"}
+
+        with patch("mindsdb.integrations.handlers.raindrop_handler.raindrop_handler.RaindropAPIClient") as mock_client:
+            mock_instance = Mock()
+            mock_client.return_value = mock_instance
+
+            handler.connect()
+            logger.info("[PASS] Connection with API key works")
+
+            # Test connection check
+            mock_instance.get_user_stats.return_value = {"result": True}
+            status = handler.check_connection()
+            logger.info(f"[PASS] Connection check works: {status.success}")
+
+        return True
+    except Exception as e:
+        logger.error(f"[FAIL] Connection handling test failed: {e}")
+        return False
+
+
+def main():
+    """Run all verification tests"""
+    logger.info("[VERIFY] Verifying Raindrop.io Handler Implementation")
+    logger.info("=" * 50)
+
+    tests = [
+        ("Handler Loading", test_handler_loading),
+        ("API Client", test_api_client),
+        ("Table Functionality", test_table_functionality),
+        ("Connection Handling", test_connection_handling),
+    ]
+
+    passed = 0
+    total = len(tests)
+
+    for test_name, test_func in tests:
+        logger.info(f"\n[TEST] {test_name}")
+        logger.info("-" * 30)
+        if test_func():
+            passed += 1
+        else:
+            logger.error(f"[FAILED] {test_name} failed")
+
+    logger.info("\n" + "=" * 50)
+    logger.info(f"[RESULTS] Test Results: {passed}/{total} tests passed")
+
+    if passed == total:
+        logger.info("[SUCCESS] All tests passed! The Raindrop.io handler is ready for use.")
+        return 0
+    else:
+        logger.error("[FAILED] Some tests failed. Please check the implementation.")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/mindsdb/integrations/handlers/s3_handler/s3_handler.py b/mindsdb/integrations/handlers/s3_handler/s3_handler.py
index e3354210bce..70d998490dc 100644
--- a/mindsdb/integrations/handlers/s3_handler/s3_handler.py
+++ b/mindsdb/integrations/handlers/s3_handler/s3_handler.py
@@ -157,7 +157,11 @@ def _connect_duckdb(self, bucket):
         # detect region for bucket
         if bucket not in self._regions:
             client = self.connect()
-            self._regions[bucket] = client.get_bucket_location(Bucket=bucket)["LocationConstraint"]
+            location = client.get_bucket_location(Bucket=bucket)["LocationConstraint"]
+            # AWS returns None for us-east-1 region (default/classic region)
+            if location is None:
+                location = "us-east-1"
+            self._regions[bucket] = location
 
         region = self._regions[bucket]
         duckdb_conn.execute(f"SET s3_region='{region}'")
diff --git a/mindsdb/integrations/handlers/snowflake_handler/requirements.txt b/mindsdb/integrations/handlers/snowflake_handler/requirements.txt
index 706f9cd675f..b267c6e302d 100644
--- a/mindsdb/integrations/handlers/snowflake_handler/requirements.txt
+++ b/mindsdb/integrations/handlers/snowflake_handler/requirements.txt
@@ -1,2 +1,2 @@
-snowflake-connector-python[pandas]==3.15.0
-snowflake-sqlalchemy==1.7.0
+snowflake-connector-python[pandas]==4.4.0
+snowflake-sqlalchemy==1.9.0
diff --git a/mindsdb/integrations/handlers/snowflake_handler/snowflake_handler.py b/mindsdb/integrations/handlers/snowflake_handler/snowflake_handler.py
index 91e20c74e50..04898c3df63 100644
--- a/mindsdb/integrations/handlers/snowflake_handler/snowflake_handler.py
+++ b/mindsdb/integrations/handlers/snowflake_handler/snowflake_handler.py
@@ -1,24 +1,28 @@
-import psutil
+from typing import Any, Optional, List, Generator
+
 import pandas
 from pandas import DataFrame
 from pandas.api import types as pd_types
 from snowflake.sqlalchemy import snowdialect
 from snowflake import connector
 from snowflake.connector.errors import NotSupportedError
-from snowflake.connector.cursor import SnowflakeCursor, ResultMetadata
-from typing import Any, Optional, List
+from snowflake.connector.cursor import ResultMetadata
 
 from mindsdb_sql_parser.ast.base import ASTNode
 from mindsdb_sql_parser.ast import Select, Identifier
 
-from mindsdb.utilities import log
 from mindsdb.integrations.libs.base import MetaDatabaseHandler
+from mindsdb.utilities import log
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb.utilities.types.column import Column
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
-    HandlerResponse as Response,
-    RESPONSE_TYPE,
+    TableResponse,
+    OkResponse,
+    ErrorResponse,
+    DataHandlerResponse,
 )
+
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 from .auth_types import (
@@ -50,9 +54,9 @@ def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
     types_map = {
         ("NUMBER", "DECIMAL", "DEC", "NUMERIC"): MYSQL_DATA_TYPE.DECIMAL,
         ("INT , INTEGER , BIGINT , SMALLINT , TINYINT , BYTEINT"): MYSQL_DATA_TYPE.INT,
-        ("FLOAT", "FLOAT4", "FLOAT8"): MYSQL_DATA_TYPE.FLOAT,
+        ("FLOAT", "FLOAT4", "FLOAT8", "FIXED"): MYSQL_DATA_TYPE.FLOAT,
         ("DOUBLE", "DOUBLE PRECISION", "REAL"): MYSQL_DATA_TYPE.DOUBLE,
-        ("VARCHAR"): MYSQL_DATA_TYPE.VARCHAR,
+        ("VARCHAR",): MYSQL_DATA_TYPE.VARCHAR,
         ("CHAR", "CHARACTER", "NCHAR"): MYSQL_DATA_TYPE.CHAR,
         ("STRING", "TEXT", "NVARCHAR"): MYSQL_DATA_TYPE.TEXT,
         ("NVARCHAR2", "CHAR VARYING", "NCHAR VARYING"): MYSQL_DATA_TYPE.VARCHAR,
@@ -61,9 +65,11 @@ def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
         ("TIMESTAMP_NTZ", "DATETIME"): MYSQL_DATA_TYPE.DATETIME,
         ("DATE",): MYSQL_DATA_TYPE.DATE,
         ("TIME",): MYSQL_DATA_TYPE.TIME,
-        ("TIMESTAMP_LTZ"): MYSQL_DATA_TYPE.DATETIME,
-        ("TIMESTAMP_TZ"): MYSQL_DATA_TYPE.DATETIME,
-        ("VARIANT", "OBJECT", "ARRAY", "MAP", "GEOGRAPHY", "GEOMETRY", "VECTOR"): MYSQL_DATA_TYPE.VARCHAR,
+        ("TIMESTAMP_LTZ",): MYSQL_DATA_TYPE.DATETIME,
+        ("TIMESTAMP_TZ",): MYSQL_DATA_TYPE.DATETIME,
+        ("OBJECT", "ARRAY"): MYSQL_DATA_TYPE.JSON,
+        ("VECTOR",): MYSQL_DATA_TYPE.VECTOR,
+        ("VARIANT", "MAP", "GEOGRAPHY", "GEOMETRY", "VECTOR"): MYSQL_DATA_TYPE.VARCHAR,
     }
 
     for db_types_list, mysql_data_type in types_map.items():
@@ -74,100 +80,85 @@ def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
     return MYSQL_DATA_TYPE.VARCHAR
 
 
-def _make_table_response(result: DataFrame, cursor: SnowflakeCursor) -> Response:
-    """Build response from result and cursor.
-    NOTE: Snowflake return only 'general' type in description, so look on result's
-          DF types and use types from description only if DF type is 'object'
+def _get_columns(description: list[ResultMetadata], sample: pandas.DataFrame = None) -> list[Column]:
+    """Get columns from Snowflake cursor description.
 
     Args:
-        result (DataFrame): result of the query.
-        cursor (SnowflakeCursor): cursor object.
+        description (list[ResultMetadata]): cursor description metadata.
+        sample (pandas.DataFrame): data sample
 
     Returns:
-        Response: response object.
+        list[Column]: list of columns with mapped MySQL types.
     """
-    description: list[ResultMetadata] = cursor.description
-    mysql_types: list[MYSQL_DATA_TYPE] = []
+    result = []
     for column in description:
-        column_dtype = result[column.name].dtype
-        description_column_type = connector.constants.FIELD_ID_TO_NAME.get(column.type_code)
-        if description_column_type in ("OBJECT", "ARRAY"):
-            mysql_types.append(MYSQL_DATA_TYPE.JSON)
-            continue
-        if description_column_type == "VECTOR":
-            mysql_types.append(MYSQL_DATA_TYPE.VECTOR)
-            continue
-        if pd_types.is_integer_dtype(column_dtype):
-            column_dtype_name = column_dtype.name
-            if column_dtype_name in ("int8", "Int8"):
-                mysql_types.append(MYSQL_DATA_TYPE.TINYINT)
-            elif column_dtype in ("int16", "Int16"):
-                mysql_types.append(MYSQL_DATA_TYPE.SMALLINT)
-            elif column_dtype in ("int32", "Int32"):
-                mysql_types.append(MYSQL_DATA_TYPE.MEDIUMINT)
-            elif column_dtype in ("int64", "Int64"):
-                mysql_types.append(MYSQL_DATA_TYPE.BIGINT)
-            else:
-                mysql_types.append(MYSQL_DATA_TYPE.INT)
-            continue
-        if pd_types.is_float_dtype(column_dtype):
-            column_dtype_name = column_dtype.name
-            if column_dtype_name in ("float16", "Float16"):  # Float16 does not exists so far
-                mysql_types.append(MYSQL_DATA_TYPE.FLOAT)
-            elif column_dtype_name in ("float32", "Float32"):
-                mysql_types.append(MYSQL_DATA_TYPE.FLOAT)
-            elif column_dtype_name in ("float64", "Float64"):
-                mysql_types.append(MYSQL_DATA_TYPE.DOUBLE)
-            else:
-                mysql_types.append(MYSQL_DATA_TYPE.FLOAT)
-            continue
-        if pd_types.is_bool_dtype(column_dtype):
-            mysql_types.append(MYSQL_DATA_TYPE.BOOLEAN)
-            continue
-        if pd_types.is_datetime64_any_dtype(column_dtype):
-            mysql_types.append(MYSQL_DATA_TYPE.DATETIME)
-            series = result[column.name]
-            # snowflake use pytz.timezone
-            if series.dt.tz is not None and getattr(series.dt.tz, "zone", "UTC") != "UTC":
-                series = series.dt.tz_convert("UTC")
-                result[column.name] = series.dt.tz_localize(None)
-            continue
-
-        if pd_types.is_object_dtype(column_dtype):
-            if description_column_type == "TEXT":
-                # we can also check column.internal_size, if == 16777216 then it is TEXT, else VARCHAR(internal_size)
-                mysql_types.append(MYSQL_DATA_TYPE.TEXT)
-                continue
-            elif description_column_type == "BINARY":
-                # if column.internal_size == 8388608 then BINARY, else VARBINARY(internal_size)
-                mysql_types.append(MYSQL_DATA_TYPE.BINARY)
-                continue
-            elif description_column_type == "DATE":
-                mysql_types.append(MYSQL_DATA_TYPE.DATE)
-                continue
-            elif description_column_type == "TIME":
-                mysql_types.append(MYSQL_DATA_TYPE.TIME)
-                continue
-
-        if description_column_type == "FIXED":
-            if column.scale == 0:
-                mysql_types.append(MYSQL_DATA_TYPE.INT)
-            else:
-                # It is NUMBER, DECIMAL or NUMERIC with scale > 0
-                mysql_types.append(MYSQL_DATA_TYPE.FLOAT)
-            continue
-        elif description_column_type == "REAL":
-            mysql_types.append(MYSQL_DATA_TYPE.FLOAT)
-            continue
-
-        mysql_types.append(MYSQL_DATA_TYPE.TEXT)
-
-    df = DataFrame(
-        result,
-        columns=[column.name for column in description],
-    )
-
-    return Response(RESPONSE_TYPE.TABLE, data_frame=df, affected_rows=None, mysql_types=mysql_types)
+        mysql_type = None
+        sf_type_name = connector.constants.FIELD_ID_TO_NAME.get(column.type_code)
+        if sf_type_name is None:
+            logger.warning(f"Snowflake handler: unknown type code: {column.type_code}")
+            mysql_type = MYSQL_DATA_TYPE.VARCHAR
+
+        if sample is not None:
+            column_dtype = sample[column.name].dtype
+
+            if pd_types.is_integer_dtype(column_dtype):
+                column_dtype_name = column_dtype.name
+                if column_dtype_name in ("int8", "Int8"):
+                    mysql_type = MYSQL_DATA_TYPE.TINYINT
+                elif column_dtype in ("int16", "Int16"):
+                    mysql_type = MYSQL_DATA_TYPE.SMALLINT
+                elif column_dtype in ("int32", "Int32"):
+                    mysql_type = MYSQL_DATA_TYPE.MEDIUMINT
+                elif column_dtype in ("int64", "Int64"):
+                    mysql_type = MYSQL_DATA_TYPE.BIGINT
+                else:
+                    mysql_type = MYSQL_DATA_TYPE.INT
+
+            elif pd_types.is_float_dtype(column_dtype):
+                column_dtype_name = column_dtype.name
+                if column_dtype_name in ("float16", "Float16"):  # Float16 does not exists so far
+                    mysql_type = MYSQL_DATA_TYPE.FLOAT
+                elif column_dtype_name in ("float32", "Float32"):
+                    mysql_type = MYSQL_DATA_TYPE.FLOAT
+                elif column_dtype_name in ("float64", "Float64"):
+                    mysql_type = MYSQL_DATA_TYPE.DOUBLE
+                else:
+                    mysql_type = MYSQL_DATA_TYPE.FLOAT
+
+            elif pd_types.is_bool_dtype(column_dtype):
+                mysql_type = MYSQL_DATA_TYPE.BOOLEAN
+
+            elif pd_types.is_datetime64_any_dtype(column_dtype):
+                mysql_type = MYSQL_DATA_TYPE.DATETIME
+                series = sample[column.name]
+                # snowflake use pytz.timezone
+                if series.dt.tz is not None and getattr(series.dt.tz, "zone", "UTC") != "UTC":
+                    series = series.dt.tz_convert("UTC")
+                    sample[column.name] = series.dt.tz_localize(None)
+
+            elif pd_types.is_object_dtype(column_dtype):
+                if sf_type_name == "TEXT":
+                    # we can also check column.internal_size, if == 16777216 then it is TEXT, else VARCHAR(internal_size)
+                    mysql_type = MYSQL_DATA_TYPE.TEXT
+                elif sf_type_name == "BINARY":
+                    # if column.internal_size == 8388608 then BINARY, else VARBINARY(internal_size)
+                    mysql_type = MYSQL_DATA_TYPE.BINARY
+                elif sf_type_name == "DATE":
+                    mysql_type = MYSQL_DATA_TYPE.DATE
+                elif sf_type_name == "TIME":
+                    mysql_type = MYSQL_DATA_TYPE.TIME
+                elif sf_type_name == "FIXED":
+                    if getattr(column, "scale", None) == 0:
+                        mysql_type = MYSQL_DATA_TYPE.INT
+                    else:
+                        # It is NUMBER, DECIMAL or NUMERIC with scale > 0
+                        mysql_type = MYSQL_DATA_TYPE.FLOAT
+
+        if mysql_type is None:
+            mysql_type = _map_type(sf_type_name)
+
+        result.append(Column(name=column.name, type=mysql_type, original_type=sf_type_name))
+    return result
 
 
 class SnowflakeHandler(MetaDatabaseHandler):
@@ -176,6 +167,7 @@ class SnowflakeHandler(MetaDatabaseHandler):
     """
 
     name = "snowflake"
+    stream_response = True
 
     _auth_types = {
         "key_pair": KeyPairAuthType(),
@@ -269,92 +261,84 @@ def check_connection(self) -> StatusResponse:
 
         return response
 
-    def native_query(self, query: str) -> Response:
-        """
-        Executes a SQL query on the Snowflake account and returns the result.
+    def native_query(self, query: str, stream: bool = True, **kwargs) -> TableResponse | OkResponse | ErrorResponse:
+        """Executes a SQL query on the Snowflake account and returns the result.
 
         Args:
             query (str): The SQL query to be executed.
+            stream (bool): If True - return TableResponse with generator inside.
 
         Returns:
-            Response: A response object containing the result of the query or an error message.
+            DataHandlerResponse: A response object containing the result of the query or an error message.
         """
+        generator = self._execute_fetch_batches(query)
+        try:
+            response: TableResponse = next(generator)
+            response.data_generator = generator
+            if stream is False:
+                response.fetchall()
+        except StopIteration as e:
+            response = e.value
+            if isinstance(response, DataHandlerResponse) is False:
+                raise
+
+        return response
+
+    def _execute_fetch_batches(
+        self, query: str
+    ) -> Generator[TableResponse | pandas.DataFrame, None, OkResponse | ErrorResponse]:
+        """Execute a SQL query and yield results in batches.
 
-        need_to_close = self.is_connected is False
+        Args:
+            query (str): The SQL query to execute.
+
+        Yields:
+            TableResponse: First yield — response with column metadata and affected row count.
+            pandas.DataFrame: Subsequent yields — batches of query results.
 
+        Returns:
+            OkResponse: For DML statements (INSERT/DELETE/UPDATE) with affected row count.
+            ErrorResponse: If an exception occurs during query execution.
+        """
         connection = self.connect()
-        with connection.cursor(connector.DictCursor) as cur:
+        with connection.cursor(connector.DictCursor) as cursor:
             try:
-                cur.execute(query)
+                cursor.execute(query)
                 try:
                     try:
-                        batches_iter = cur.fetch_pandas_batches()
+                        batches_iter = cursor.fetch_pandas_batches()
                     except ValueError:
                         # duplicated columns raises ValueError
                         raise NotSupportedError()
-
-                    batches = []
-                    memory_estimation_check_done = False
-                    batches_rowcount = 0
-                    total_rowcount = cur.rowcount or 0
+                    try:
+                        sample_df = next(batches_iter)
+                    except StopIteration:
+                        sample_df = None
+                    columns = _get_columns(cursor.description, sample=sample_df)
+                    yield TableResponse(data=sample_df, affected_rows=cursor.rowcount, columns=columns)
                     for batch_df in batches_iter:
-                        batches.append(batch_df)
-                        # region check the size of first batch (if it is big enough) to get an estimate of the full
-                        # dataset size. If it does not fit in memory - raise an error.
-                        # NOTE batch size cannot be set on client side. Also, Snowflake will download
-                        # 'CLIENT_PREFETCH_THREADS' count of chunks in parallel (by default 4), therefore this check
-                        # can not work in some cases.
-                        batches_rowcount += len(batch_df)
-                        if memory_estimation_check_done is False and batches_rowcount > 1000:
-                            memory_estimation_check_done = True
-                            available_memory_kb = psutil.virtual_memory().available >> 10
-                            batches_size_kb = sum(
-                                [(x.memory_usage(index=True, deep=True).sum() >> 10) for x in batches]
-                            )
-                            rest_rowcount = total_rowcount - batches_rowcount
-                            rest_estimated_size_kb = int((rest_rowcount / batches_rowcount) * batches_size_kb)
-                            # for pd.concat required at least x2 memory
-                            max_allowed_memory_kb = available_memory_kb / 2.4
-                            if max_allowed_memory_kb < rest_estimated_size_kb:
-                                error_message = (
-                                    "The query result is too large to fit into available memory. "
-                                    f"The dataset contains {total_rowcount} rows with an estimated size "
-                                    f"of {rest_estimated_size_kb} KB, but only {max_allowed_memory_kb:.0f} KB "
-                                    f"of memory is allowed fot the dataset. Please narrow down the query by adding filters "
-                                    f"or a LIMIT clause to reduce the result set size."
-                                )
-                                logger.error(error_message)
-                                raise MemoryError(error_message)
-                        # endregion
-                    if len(batches) > 0:
-                        response = _make_table_response(result=pandas.concat(batches, ignore_index=True), cursor=cur)
-                    else:
-                        response = Response(RESPONSE_TYPE.TABLE, DataFrame([], columns=[x[0] for x in cur.description]))
+                        yield batch_df
                 except NotSupportedError:
                     # Fallback for CREATE/DELETE/UPDATE. These commands returns table with single column,
                     # but it cannot be retrieved as pandas DataFrame.
-                    result = cur.fetchall()
+                    result = cursor.fetchall()
                     match result:
                         case (
                             [{"number of rows inserted": affected_rows}]
                             | [{"number of rows deleted": affected_rows}]
                             | [{"number of rows updated": affected_rows, "number of multi-joined rows updated": _}]
                         ):
-                            response = Response(RESPONSE_TYPE.OK, affected_rows=affected_rows)
+                            response = OkResponse(affected_rows=affected_rows)
                         case list():
-                            response = Response(
-                                RESPONSE_TYPE.TABLE, DataFrame(result, columns=[x[0] for x in cur.description])
-                            )
+                            response = TableResponse(data=DataFrame(result, columns=[x[0] for x in cursor.description]))
                         case _:
                             # Looks like SnowFlake always returns something in response, so this is suspicious
                             logger.warning("Snowflake did not return any data in response.")
-                            response = Response(RESPONSE_TYPE.OK)
+                            response = OkResponse()
+                    return response
             except Exception as e:
                 logger.error(f"Error running query: {query} on {self.connection_data.get('database')}, {e}!")
-                response = Response(RESPONSE_TYPE.ERROR, error_code=0, error_message=str(e))
-
-        if need_to_close is True:
-            self.disconnect()
+                return ErrorResponse(error_code=0, error_message=str(e))
 
         if memory_pool is not None and memory_pool.backend_name == "jemalloc":
             # This reduce memory consumption, but will slow down next query slightly.
@@ -362,9 +346,7 @@ def native_query(self, query: str) -> Response:
             # and next query processing time may be even lower.
             memory_pool.release_unused()
 
-        return response
-
-    def query(self, query: ASTNode) -> Response:
+    def query(self, query: ASTNode) -> DataHandlerResponse:
         """
         Executes a SQL query represented by an ASTNode and retrieves the data.
 
@@ -372,7 +354,7 @@ def query(self, query: ASTNode) -> Response:
             query (ASTNode): An ASTNode representing the SQL query to be executed.
 
         Returns:
-            Response: The response from the `native_query` method, containing the result of the SQL query execution.
+            DataHandlerResponse: The response from the `native_query` method, containing the result of the SQL query execution.
         """
 
         query_str = self.renderer.get_string(query, with_failback=True)
@@ -381,7 +363,7 @@ def query(self, query: ASTNode) -> Response:
         return self.lowercase_columns(result, query)
 
     def lowercase_columns(self, result, query):
-        if not isinstance(query, Select) or result.data_frame is None:
+        if not isinstance(query, Select) or not isinstance(result, TableResponse):
             return result
 
         quoted_columns = []
@@ -394,20 +376,19 @@ def lowercase_columns(self, result, query):
                     if column.is_quoted[-1]:
                         quoted_columns.append(column.parts[-1])
 
-        rename_columns = {}
-        for col in result.data_frame.columns:
-            if col.isupper() and col not in quoted_columns:
-                rename_columns[col] = col.lower()
-        if rename_columns:
-            result.data_frame = result.data_frame.rename(columns=rename_columns)
+        for col in result.columns:
+            col_name = col.alias or col.name
+            if col_name.isupper() and col_name not in quoted_columns:
+                col.alias = col_name.lower()
+
         return result
 
-    def get_tables(self) -> Response:
+    def get_tables(self) -> DataHandlerResponse:
         """
         Retrieves a list of all non-system tables and views in the current schema of the Snowflake account.
 
         Returns:
-            Response: A response object containing the list of tables and views, formatted as per the `Response` class.
+            DataHandlerResponse: A response object containing the list of tables and views.
         """
 
         query = """
@@ -418,7 +399,7 @@ def get_tables(self) -> Response:
         """
         return self.native_query(query)
 
-    def get_columns(self, table_name) -> Response:
+    def get_columns(self, table_name) -> DataHandlerResponse:
         """
         Retrieves column details for a specified table in the Snowflake account.
 
@@ -426,7 +407,7 @@ def get_columns(self, table_name) -> Response:
             table_name (str): The name of the table for which to retrieve column information.
 
         Returns:
-            Response: A response object containing the column details, formatted as per the `Response` class.
+            DataHandlerResponse: A response object containing the column details.
 
         Raises:
             ValueError: If the 'table_name' is not a valid string.
@@ -458,7 +439,7 @@ def get_columns(self, table_name) -> Response:
 
         return result
 
-    def meta_get_tables(self, table_names: Optional[List[str]] = None) -> Response:
+    def meta_get_tables(self, table_names: Optional[List[str]] = None) -> DataHandlerResponse:
         """
         Retrieves metadata information about the tables in the Snowflake database to be stored in the data catalog.
 
@@ -466,7 +447,7 @@ def meta_get_tables(self, table_names: Optional[List[str]] = None) -> Response:
             table_names (list): A list of table names for which to retrieve metadata information.
 
         Returns:
-            Response: A response object containing the metadata information, formatted as per the `Response` class.
+            DataHandlerResponse: A response object containing the metadata information.
         """
         query = """
             SELECT
@@ -493,7 +474,7 @@ def meta_get_tables(self, table_names: Optional[List[str]] = None) -> Response:
             result.data_frame["ROW_COUNT"] = result.data_frame["ROW_COUNT"].astype("Int64")
         return result
 
-    def meta_get_columns(self, table_names: Optional[List[str]] = None) -> Response:
+    def meta_get_columns(self, table_names: Optional[List[str]] = None) -> DataHandlerResponse:
         """
         Retrieves column metadata for the specified tables (or all tables if no list is provided).
 
@@ -501,7 +482,7 @@ def meta_get_columns(self, table_names: Optional[List[str]] = None) -> Response:
             table_names (list): A list of table names for which to retrieve column metadata.
 
         Returns:
-            Response: A response object containing the column metadata.
+            DataHandlerResponse: A response object containing the column metadata.
         """
         query = """
             SELECT
@@ -529,7 +510,7 @@ def meta_get_columns(self, table_names: Optional[List[str]] = None) -> Response:
         result = self.native_query(query)
         return result
 
-    def meta_get_column_statistics(self, table_names: Optional[List[str]] = None) -> Response:
+    def meta_get_column_statistics(self, table_names: Optional[List[str]] = None) -> DataHandlerResponse:
         """
         Retrieves basic column statistics: null %, distinct count.
         Due to Snowflake limitations, this runs per-table not per-column.
@@ -546,11 +527,11 @@ def meta_get_column_statistics(self, table_names: Optional[List[str]] = None) ->
 
         columns_result = self.native_query(columns_query)
         if (
-            columns_result.type == RESPONSE_TYPE.ERROR
+            isinstance(columns_result, ErrorResponse)
             or columns_result.data_frame is None
             or columns_result.data_frame.empty
         ):
-            return Response(RESPONSE_TYPE.ERROR, error_message="No columns found.")
+            return ErrorResponse(error_message="No columns found.")
 
         columns_df = columns_result.data_frame
         grouped = columns_df.groupby(["TABLE_SCHEMA", "TABLE_NAME"])
@@ -585,9 +566,13 @@ def meta_get_column_statistics(self, table_names: Optional[List[str]] = None) ->
             """
             try:
                 stats_res = self.native_query(stats_query)
-                if stats_res.type != RESPONSE_TYPE.TABLE or stats_res.data_frame is None or stats_res.data_frame.empty:
+                if (
+                    not isinstance(stats_res, TableResponse)
+                    or stats_res.data_frame is None
+                    or stats_res.data_frame.empty
+                ):
                     logger.warning(
-                        f"Could not retrieve stats for table {table_name}. Query returned no data or an error: {stats_res.error_message if stats_res.type == RESPONSE_TYPE.ERROR else 'No data'}"
+                        f"Could not retrieve stats for table {table_name}. Query returned no data or an error: {stats_res.error_message if isinstance(stats_res, ErrorResponse) else 'No data'}"
                     )
                     # Add placeholder stats if query fails or returns empty
                     for _, row in group.iterrows():
@@ -646,11 +631,11 @@ def meta_get_column_statistics(self, table_names: Optional[List[str]] = None) ->
                     )
 
         if not all_stats:
-            return Response(RESPONSE_TYPE.TABLE, data_frame=pandas.DataFrame())
+            return TableResponse(data=pandas.DataFrame())
 
-        return Response(RESPONSE_TYPE.TABLE, data_frame=pandas.DataFrame(all_stats))
+        return TableResponse(data=pandas.DataFrame(all_stats))
 
-    def meta_get_primary_keys(self, table_names: Optional[List[str]] = None) -> Response:
+    def meta_get_primary_keys(self, table_names: Optional[List[str]] = None) -> DataHandlerResponse:
         """
         Retrieves primary key information for the specified tables (or all tables if no list is provided).
 
@@ -658,7 +643,7 @@ def meta_get_primary_keys(self, table_names: Optional[List[str]] = None) -> Resp
             table_names (list): A list of table names for which to retrieve primary key information.
 
         Returns:
-            Response: A response object containing the primary key information.
+            DataHandlerResponse: A response object containing the primary key information.
         """
         try:
             query = """
@@ -666,7 +651,7 @@ def meta_get_primary_keys(self, table_names: Optional[List[str]] = None) -> Resp
             """
 
             response = self.native_query(query)
-            if response.type == RESPONSE_TYPE.ERROR and response.error_message:
+            if isinstance(response, ErrorResponse):
                 logger.error(f"Query error in meta_get_primary_keys: {response.error_message}\nQuery:\n{query}")
 
             df = response.data_frame
@@ -683,9 +668,9 @@ def meta_get_primary_keys(self, table_names: Optional[List[str]] = None) -> Resp
 
         except Exception as e:
             logger.error(f"Exception in meta_get_primary_keys: {e!r}")
-            return Response(RESPONSE_TYPE.ERROR, error_message=f"Exception querying primary keys: {e!r}")
+            return ErrorResponse(error_message=f"Exception querying primary keys: {e!r}")
 
-    def meta_get_foreign_keys(self, table_names: Optional[List[str]] = None) -> Response:
+    def meta_get_foreign_keys(self, table_names: Optional[List[str]] = None) -> DataHandlerResponse:
         """
         Retrieves foreign key information for the specified tables (or all tables if no list is provided).
 
@@ -693,7 +678,7 @@ def meta_get_foreign_keys(self, table_names: Optional[List[str]] = None) -> Resp
             table_names (list): A list of table names for which to retrieve foreign key information.
 
         Returns:
-            Response: A response object containing the foreign key information.
+            DataHandlerResponse: A response object containing the foreign key information.
         """
         try:
             query = """
@@ -701,7 +686,7 @@ def meta_get_foreign_keys(self, table_names: Optional[List[str]] = None) -> Resp
             """
 
             response = self.native_query(query)
-            if response.type == RESPONSE_TYPE.ERROR and response.error_message:
+            if isinstance(response, ErrorResponse):
                 logger.error(f"Query error in meta_get_primary_keys: {response.error_message}\nQuery:\n{query}")
 
             df = response.data_frame
@@ -712,10 +697,10 @@ def meta_get_foreign_keys(self, table_names: Optional[List[str]] = None) -> Resp
                 df = df[["pk_table_name", "pk_column_name", "fk_table_name", "fk_column_name"]]
                 df = df.rename(
                     columns={
-                        "pk_table_name": "child_table_name",
-                        "pk_column_name": "child_column_name",
-                        "fk_table_name": "parent_table_name",
-                        "fk_column_name": "parent_column_name",
+                        "pk_table_name": "parent_table_name",
+                        "pk_column_name": "parent_column_name",
+                        "fk_table_name": "child_table_name",
+                        "fk_column_name": "child_column_name",
                     }
                 )
 
@@ -725,7 +710,7 @@ def meta_get_foreign_keys(self, table_names: Optional[List[str]] = None) -> Resp
 
         except Exception as e:
             logger.error(f"Exception in meta_get_primary_keys: {e!r}")
-            return Response(RESPONSE_TYPE.ERROR, error_message=f"Exception querying primary keys: {e!r}")
+            return ErrorResponse(error_message=f"Exception querying primary keys: {e!r}")
 
     def meta_get_handler_info(self, **kwargs: Any) -> str:
         """
diff --git a/mindsdb/integrations/handlers/strapi_handler/README.md b/mindsdb/integrations/handlers/strapi_handler/README.md
index 5595ce71c99..5a9341bd308 100644
--- a/mindsdb/integrations/handlers/strapi_handler/README.md
+++ b/mindsdb/integrations/handlers/strapi_handler/README.md
@@ -13,7 +13,7 @@ The Strapi handler is initialized with the following parameters:
 - `host` - the host of the Strapi server
 - `port` - the port of the Strapi server
 - `api_token` - the api token of the Strapi server
-- `plural_api_ids` - the list of plural api ids of the collections
+- `endpoints` - the list of collection endpoints
 
 ## Implemented Features
 
@@ -36,7 +36,7 @@ PARAMETERS = {
   "host" : "<strapi-host>", --- host, it can be an ip or an url.
   "port" : "<strapi-port>",  --- common port is 1337.
   "api_token": "<your-strapi-api-token>", --- api token of the strapi server.
-  "plural_api_ids" : ["<plural-api-id>"] --- plural api ids of the collections.
+  "endpoints" : ["<collection-endpoint>"] --- collection endpoints.
 };
 ```
 
@@ -49,7 +49,7 @@ PARAMETERS = {
   "host" : "localhost",
   "port" : "1337",
   "api_token": "c56c000d867e95848c",
-  "plural_api_ids" : ["products", "sellers"]
+  "endpoints" : ["products", "sellers"]
 };
 ```
 
@@ -84,7 +84,7 @@ Example:
 ```sql
 SELECT description, price
 FROM myshop.products
-WHERE id = 1;
+WHERE documentId = 'mvaprjyy72ayx7z4v592sdnr';
 ```
 
 ---
@@ -140,7 +140,7 @@ Example
 UPDATE myshop.products
 SET price = 299,
 avaiablity = false
-WHERE id = 1;
+WHERE documentId = 'mvaprjyy72ayx7z4v592sdnr';
 ```
 
 Note: You only able to update data into the collection which has `update` permission.
diff --git a/mindsdb/integrations/handlers/strapi_handler/__about__.py b/mindsdb/integrations/handlers/strapi_handler/__about__.py
index 199f17ec162..d86a20889b2 100644
--- a/mindsdb/integrations/handlers/strapi_handler/__about__.py
+++ b/mindsdb/integrations/handlers/strapi_handler/__about__.py
@@ -1,6 +1,6 @@
 __title__ = "MindsDB Strapi handler"
 __package_name__ = "mindsdb_strapi_handler"
-__version__ = "0.0.1"
+__version__ = "0.0.2"
 __description__ = "MindsDB handler for Strapi"
 __author__ = "Ritwick Raj Makhal"
 __github__ = "https://github.com/mindsdb/mindsdb"
diff --git a/mindsdb/integrations/handlers/strapi_handler/strapi_handler.py b/mindsdb/integrations/handlers/strapi_handler/strapi_handler.py
index 2338edc0f0d..555f3ce96e0 100644
--- a/mindsdb/integrations/handlers/strapi_handler/strapi_handler.py
+++ b/mindsdb/integrations/handlers/strapi_handler/strapi_handler.py
@@ -1,6 +1,6 @@
 from mindsdb.integrations.handlers.strapi_handler.strapi_tables import StrapiTable
 from mindsdb.integrations.libs.api_handler import APIHandler
-from mindsdb.integrations.libs.response import HandlerStatusResponse as StatusResponse
+from mindsdb.integrations.libs.response import HandlerResponse, RESPONSE_TYPE, HandlerStatusResponse as StatusResponse
 from mindsdb_sql_parser import parse_sql
 from mindsdb.utilities import log
 import requests
@@ -20,18 +20,40 @@ def __init__(self, name: str, **kwargs) -> None:
         """
         super().__init__(name)
 
-        self.connection = None
-        self.is_connected = False
-        args = kwargs.get('connection_data', {})
-        if 'host' in args and 'port' in args:
-            self._base_url = f"http://{args['host']}:{args['port']}"
-        if 'api_token' in args:
-            self._api_token = args['api_token']
-        if 'plural_api_ids' in args:
-            self._plural_api_ids = args['plural_api_ids']
-        # Registers tables for each collections in strapi
-        for pluralApiId in self._plural_api_ids:
-            self._register_table(table_name=pluralApiId, table_class=StrapiTable(handler=self, name=pluralApiId))
+        self._connection_cache = {}
+        self._table_schemas = {}
+
+        args = kwargs.get("connection_data", {})
+        # Handle both complete URLs and host+port combinations
+        if "url" in args and args.get("url"):
+            # Complete URL provided (e.g., https://my-strapi.herokuapp.com)
+            self._base_url = args.get("url").rstrip("/")
+        elif "host" in args and args.get("host"):
+            # Traditional host + port setup
+            host = args.get("host", "")
+            port = args.get("port", "")
+
+            # Determine protocol
+            protocol = "https" if args.get("ssl", False) else "http"
+
+            if port:
+                self._base_url = f"{protocol}://{host}:{port}"
+            else:
+                self._base_url = f"{protocol}://{host}"
+        else:
+            self._base_url = None
+        self._api_token = args.get("api_token")
+        self._endpoints = args.get("endpoints", [])
+
+        self._connection_key = f"{self._base_url}_{self._api_token}"
+
+        # Use cached connection status
+        self.is_connected = self._connection_cache.get(self._connection_key, False)
+
+        # Register tables but defer schema fetching
+        for endpoint in self._endpoints:
+            table_instance = StrapiTable(handler=self, name=endpoint, defer_schema_fetch=True)
+            self._register_table(table_name=endpoint, table_class=table_instance)
 
     def check_connection(self) -> StatusResponse:
         """checking the connection
@@ -39,36 +61,50 @@ def check_connection(self) -> StatusResponse:
         Returns:
             StatusResponse: whether the connection is still up
         """
-        response = StatusResponse(False)
-        try:
-            self.connect()
-            response.success = True
-        except Exception as e:
-            logger.error(f'Error connecting to Strapi API: {e}!')
-            response.error_message = e
-
-        self.is_connected = response.success
-        return response
+        if self._connection_cache.get(self._connection_key, False):
+            self.is_connected = True
+            return StatusResponse(True)
+        return self.connect()
 
     def connect(self) -> StatusResponse:
-        """making the connectino object
-        """
-        if self.is_connected and self.connection:
-            return self.connection
+        """making the connectino object"""
+        if self._connection_cache.get(self._connection_key, False):
+            self.is_connected = True
+            return StatusResponse(True)
 
         try:
             headers = {"Authorization": f"Bearer {self._api_token}"}
             response = requests.get(f"{self._base_url}", headers=headers)
             if response.status_code == 200:
-                self.connection = response
                 self.is_connected = True
+                self._connection_cache[self._connection_key] = True
                 return StatusResponse(True)
             else:
                 raise Exception(f"Error connecting to Strapi API: {response.status_code} - {response.text}")
         except Exception as e:
-            logger.error(f'Error connecting to Strapi API: {e}!')
+            logger.error(f"Error connecting to Strapi API: {e}!")
+            self._connection_cache[self._connection_key] = False
             return StatusResponse(False, error_message=e)
 
+    def get_tables(self) -> HandlerResponse:
+        """
+        Return list of available Strapi collections
+        Returns:
+            RESPONSE_TYPE.TABLE
+        """
+        result = self._endpoints
+
+        df = pd.DataFrame(result, columns=["table_name"])
+        df["table_type"] = "BASE TABLE"
+
+        return HandlerResponse(RESPONSE_TYPE.TABLE, df)
+
+    def get_table(self, table_name: str):
+        """Create table instance on demand"""
+        if table_name in self._endpoints:
+            return StrapiTable(handler=self, name=table_name)
+        raise ValueError(f"Table {table_name} not found in your Strapi collections.")
+
     def native_query(self, query: str) -> StatusResponse:
         """Receive and process a raw query.
 
@@ -86,32 +122,39 @@ def native_query(self, query: str) -> StatusResponse:
         return self.query(ast)
 
     def call_strapi_api(self, method: str, endpoint: str, params: dict = {}, json_data: dict = {}) -> pd.DataFrame:
-        headers = {"Authorization": f"Bearer {self._api_token}"}
-        url = f"{self._base_url}{endpoint}"
+        headers = {"Content-Type": "application/json"}
+        # Add Authorization header only if API token is provided
+        if self._api_token:
+            headers["Authorization"] = f"Bearer {self._api_token}"
 
-        if method.upper() in ('GET', 'POST', 'PUT', 'DELETE'):
-            headers['Content-Type'] = 'application/json'
+        url = f"{self._base_url}{endpoint}"
 
-            if method.upper() in ('POST', 'PUT', 'DELETE'):
+        if method.upper() in ("GET", "POST", "PUT", "DELETE"):
+            if method.upper() in ("POST", "PUT", "DELETE"):
                 response = requests.request(method, url, headers=headers, params=params, data=json_data)
             else:
                 response = requests.get(url, headers=headers, params=params)
 
-            if response.status_code == 200:
-                data = response.json()
-                # Create an empty DataFrame
-                df = pd.DataFrame()
-                if isinstance(data.get('data', None), list):
-                    for item in data['data']:
-                        # Add 'id' and 'attributes' to the DataFrame
-                        row_data = {'id': item['id'], **item['attributes']}
-                        df = df._append(row_data, ignore_index=True)
-                    return df
-                elif isinstance(data.get('data', None), dict):
-                    # Add 'id' and 'attributes' to the DataFrame
-                    row_data = {'id': data['data']['id'], **data['data']['attributes']}
-                    df = df._append(row_data, ignore_index=True)
-                    return df
+            if response.status_code == 200 or response.status_code == 201:
+                response_data = response.json()
+
+                # Check if response has 'data' key
+                if "data" not in response_data:
+                    raise Exception(f"Malformed API response: missing 'data' key in response from {endpoint}")
+
+                data = response_data["data"]
+
+                # Check if data is of expected type (list or dict)
+                if isinstance(data, list):
+                    df = pd.DataFrame(data)
+                elif isinstance(data, dict):
+                    df = pd.DataFrame([data])
+                else:
+                    raise Exception(
+                        f"Malformed API response: 'data' key contains unexpected type {type(data).__name__}, expected list or dict from {endpoint}"
+                    )
+
+                return df
             else:
                 raise Exception(f"Error connecting to Strapi API: {response.status_code} - {response.text}")
 
@@ -137,11 +180,11 @@ def call_strapi_api(self, method: str, endpoint: str, params: dict = {}, json_da
         "required": True,
         "label": "Port",
     },
-    plural_api_ids={
+    endpoints={
         "type": list,
-        "description": "Plural API id to use for querying.",
+        "description": "Collection endpoints to use for querying.",
         "required": True,
-        "label": "Plural API id",
+        "label": "Endpoints",
     },
 )
 
@@ -149,5 +192,5 @@ def call_strapi_api(self, method: str, endpoint: str, params: dict = {}, json_da
     host="localhost",
     port=1337,
     api_token="c56c000d867e95848c",
-    plural_api_ids=["posts", "portfolios"],
+    endpoints=["posts", "portfolios"],
 )
diff --git a/mindsdb/integrations/handlers/strapi_handler/strapi_tables.py b/mindsdb/integrations/handlers/strapi_handler/strapi_tables.py
index 48b125ad976..df7a3e59abf 100644
--- a/mindsdb/integrations/handlers/strapi_handler/strapi_tables.py
+++ b/mindsdb/integrations/handlers/strapi_handler/strapi_tables.py
@@ -1,19 +1,284 @@
-from typing import List
+from typing import List, Dict, Any
 import pandas as pd
 from mindsdb.integrations.libs.api_handler import APIHandler, APITable
 from mindsdb_sql_parser import ast
 from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
+from mindsdb_sql_parser.ast.select.operation import BetweenOperation
 from mindsdb_sql_parser.ast.select.constant import Constant
+from mindsdb_sql_parser.ast.base import ASTNode
 import json
 
 
-class StrapiTable(APITable):
+def extract_or_conditions(node: ASTNode) -> list:
+    """Extract WHERE conditions as DNF (OR of AND groups).
+
+    Args:
+        node: The AST node representing the WHERE clause
+
+    Returns:
+        List of conjunction groups where each inner list is ANDed and
+        outer list is ORed.
+
+        Examples:
+        - a = 1 AND b = 2 -> [[(a=1), (b=2)]]
+        - a = 1 OR b = 2 -> [[(a=1)], [(b=2)]]
+        - a = 1 OR (b = 2 AND c = 4) -> [[(a=1)], [(b=2), (c=4)]]
+    """
+
+    def extract_single_condition(node: ASTNode) -> tuple:
+        if isinstance(node, ast.BinaryOperation):
+            op = node.op.lower()
+            arg1, arg2 = node.args
+            if not isinstance(arg1, ast.Identifier):
+                raise NotImplementedError(f"Not implemented arg1: {arg1}")
+            if isinstance(arg2, ast.Constant):
+                value = arg2.value
+                return (op, arg1.parts[-1], value)
+        # Add this new condition for BETWEEN
+        elif isinstance(node, BetweenOperation):
+            field = node.args[0]  # The field being tested
+            min_val = node.args[1]  # Lower bound
+            max_val = node.args[2]  # Upper bound
+
+            if (
+                isinstance(field, ast.Identifier)
+                and isinstance(min_val, ast.Constant)
+                and isinstance(max_val, ast.Constant)
+            ):
+                return ("between", field.parts[-1], [min_val.value, max_val.value])
+            else:
+                raise NotImplementedError("BETWEEN with non-constant values not supported")
+
+        raise NotImplementedError(f"Unsupported condition type: {type(node)}")
+
+    def extract_conditions_recursive(node: ASTNode) -> list:
+        if isinstance(node, ast.BinaryOperation):
+            if node.op.lower() == "or":
+                left_conditions = extract_conditions_recursive(node.args[0])
+                right_conditions = extract_conditions_recursive(node.args[1])
+                return left_conditions + right_conditions
+
+            elif node.op.lower() == "and":
+                left_conditions = extract_conditions_recursive(node.args[0])
+                right_conditions = extract_conditions_recursive(node.args[1])
+
+                combined = []
+                for left_group in left_conditions:
+                    for right_group in right_conditions:
+                        combined.append(left_group + right_group)
+                return combined
+
+            else:
+                condition = extract_single_condition(node)
+                return [[condition]]  # Single condition in its own group
 
-    def __init__(self, handler: APIHandler, name: str):
+        elif isinstance(node, BetweenOperation):
+            condition = extract_single_condition(node)
+            return [[condition]]  # Single condition in its own group
+
+        raise NotImplementedError(f"Unsupported node type: {type(node)}")
+
+    try:
+        conditions = extract_conditions_recursive(node)
+        return conditions
+    except Exception:
+        return [[]]
+
+
+# Mapping SQL operators to Strapi filter operators
+OPERATOR_MAP = {
+    "=": "$eq",
+    "!=": "$ne",
+    ">": "$gt",
+    ">=": "$gte",
+    "<": "$lt",
+    "<=": "$lte",
+    "IN": "$in",
+    "NOT IN": "$notIn",
+}
+
+
+class StrapiTable(APITable):
+    def __init__(self, handler: APIHandler, name: str, defer_schema_fetch: bool = False):
         super().__init__(handler)
         self.name = name
-        # get all the fields of a collection as columns
-        self.columns = self.handler.call_strapi_api(method='GET', endpoint=f'/api/{name}').columns
+        self._schema_fetched = False
+
+        if not defer_schema_fetch:
+            self._fetch_schema()
+        else:
+            # Set basic Strapi columns as placeholder
+            self.columns = ["id", "documentId", "createdAt", "updatedAt"]
+
+    def _fetch_schema(self):
+        """Fetch schema from Strapi API"""
+        if self._schema_fetched:
+            return
+
+        # Use cached schema if available
+        schema_key = f"{self.handler._connection_key}_{self.name}"
+        if schema_key in self.handler._table_schemas:
+            self.columns = self.handler._table_schemas[schema_key]
+            self._schema_fetched = True
+            return
+
+        # Only fetch schema once and cache it
+        try:
+            df = self.handler.call_strapi_api(
+                method="GET", endpoint=f"/api/{self.name}", params={"pagination[limit]": 1}
+            )
+            if len(df.columns) > 0:
+                self.columns = df.columns.tolist()
+                self.handler._table_schemas[schema_key] = self.columns
+            else:
+                # If no data, set basic Strapi columns
+                self.columns = ["id", "documentId", "createdAt", "updatedAt"]
+                self.handler._table_schemas[schema_key] = self.columns
+        except Exception:
+            # Set basic Strapi columns as fallback
+            self.columns = ["id", "documentId", "createdAt", "updatedAt"]
+            self.handler._table_schemas[schema_key] = self.columns
+
+        self._schema_fetched = True
+
+    def _build_filters(self, conditions: List[List[tuple]]) -> Dict[str, Any]:
+        """Build Strapi filters from DNF condition groups.
+
+        Args:
+            conditions: DNF groups where each inner list is ANDed and
+                groups are ORed.
+
+        Returns:
+            Dict of Strapi filter parameters
+        """
+        if not conditions:
+            return {}
+
+        # Keep the fast-path for direct documentId lookup.
+        if len(conditions) == 1 and len(conditions[0]) == 1:
+            op, field, value = conditions[0][0]
+            if field == "documentId" and op == "=":
+                return {"documentId": value}
+
+        def to_filter_node(condition: tuple) -> Dict[str, Dict[str, Any]]:
+            op, field, value = condition
+            return self._build_single_condition(op, field, value)
+
+        # Build nested Strapi filter tree preserving boolean precedence.
+        if len(conditions) == 1:
+            and_group = conditions[0]
+            if len(and_group) == 1:
+                filter_tree = to_filter_node(and_group[0])
+            else:
+                filter_tree = {"$and": [to_filter_node(condition) for condition in and_group]}
+        else:
+            or_nodes = []
+            for and_group in conditions:
+                if len(and_group) == 1:
+                    or_nodes.append(to_filter_node(and_group[0]))
+                else:
+                    or_nodes.append({"$and": [to_filter_node(condition) for condition in and_group]})
+            filter_tree = {"$or": or_nodes}
+
+        filters = {}
+
+        def flatten(node: Any, path: List[str]) -> None:
+            if isinstance(node, dict):
+                for key, value in node.items():
+                    flatten(value, path + [key])
+            elif isinstance(node, list):
+                for index, value in enumerate(node):
+                    flatten(value, path + [str(index)])
+            else:
+                key = "filters" + "".join(f"[{part}]" for part in path)
+                filters[key] = node
+
+        flatten(filter_tree, [])
+        return filters
+
+    def _build_single_condition(self, op: str, field: str, value: Any) -> Dict[str, Dict[str, Any]]:
+        """Build a single condition dictionary for Strapi filters
+
+        Args:
+            op: SQL operator
+            field: Field name
+            value: Field value
+
+        Returns:
+            Dictionary with field and its filter conditions
+        """
+        condition = {}
+
+        if op.upper() == "BETWEEN":
+            if isinstance(value, (list, tuple)) and len(value) == 2:
+                # BETWEEN translates to field >= min AND field <= max
+                condition[field] = {"$gte": value[0], "$lte": value[1]}
+            else:
+                raise ValueError("BETWEEN operator requires exactly 2 values")
+
+        elif op.upper() == "LIKE":
+            if not isinstance(value, str):
+                raise ValueError("LIKE operator requires a string value")
+
+            # Remove quotes if present
+            if (value.startswith("'") and value.endswith("'")) or (value.startswith('"') and value.endswith('"')):
+                value = value[1:-1]
+
+            # Handle LIKE patterns
+            if value.startswith("%") and value.endswith("%"):
+                value = value[1:-1]  # Remove % from both ends
+                condition[field] = {"$contains": value}
+            elif value.startswith("%"):
+                value = value[1:]  # Remove leading %
+                condition[field] = {"$endsWith": value}
+            elif value.endswith("%"):
+                value = value[:-1]  # Remove trailing %
+                condition[field] = {"$startsWith": value}
+            else:
+                condition[field] = {"$eq": value}
+
+        elif op.upper() == "IS":
+            if value is None:
+                condition[field] = {"$null": True}
+            else:
+                raise ValueError(f"IS operator with non-null value not supported: {value}")
+
+        elif op.upper() == "IS NOT":
+            if value is None:
+                condition[field] = {"$notNull": True}
+            else:
+                raise ValueError(f"IS NOT operator with non-null value not supported: {value}")
+
+        elif op.upper() in ("IN", "NOT IN"):
+            if isinstance(value, (list, tuple)):
+                strapi_op = "$in" if op.upper() == "IN" else "$notIn"
+                condition[field] = {strapi_op: list(value)}
+            else:
+                raise ValueError(f"{op} operator requires a list or tuple value")
+
+        elif op.upper() in OPERATOR_MAP:
+            condition[field] = {OPERATOR_MAP[op.upper()]: value}
+
+        else:
+            raise ValueError(f"Unsupported operator {op} in WHERE clause")
+
+        return condition
+
+    def _fetch_by_id(self, document_id: str, selected_columns: list) -> pd.DataFrame:
+        """Helper method to fetch a record by documentId
+
+        Args:
+            document_id (str): The documentId to fetch
+            selected_columns (list): Columns to include in result
+
+        Returns:
+            pd.DataFrame: The resulting DataFrame
+        """
+        df = self.handler.call_strapi_api(method="GET", endpoint=f"/api/{self.name}/{document_id}")
+
+        if len(df) > 0:
+            return df[selected_columns]
+        return pd.DataFrame(columns=selected_columns)
 
     def select(self, query: ast.Select) -> pd.DataFrame:
         """Triggered at the SELECT query
@@ -24,19 +289,8 @@ def select(self, query: ast.Select) -> pd.DataFrame:
         Returns:
             pd.DataFrame: The queried information
         """
-        # Initialize _id and selected_columns
-        _id = None
-        selected_columns = []
-
-        # Get id from where clause, if available
-        conditions = extract_comparison_conditions(query.where)
-        for op, arg1, arg2 in conditions:
-            if arg1 == 'id' and op == '=':
-                _id = arg2
-            else:
-                raise ValueError("Unsupported condition in WHERE clause")
-
         # Get selected columns from query
+        selected_columns = []
         for target in query.targets:
             if isinstance(target, ast.Star):
                 selected_columns = self.get_columns()
@@ -46,43 +300,77 @@ def select(self, query: ast.Select) -> pd.DataFrame:
             else:
                 raise ValueError(f"Unknown query target {type(target)}")
 
-        # Initialize the result DataFrame
-        result_df = None
+        # Default to all columns if no columns are selected
+        if not selected_columns:
+            selected_columns = self.get_columns()
 
-        if _id is not None:
-            # Fetch data using the provided endpoint for the specific id
-            df = self.handler.call_strapi_api(method='GET', endpoint=f'/api/{self.name}/{_id}')
+        # Build filters from WHERE clause
+        filters = {}
+        if query.where:
+            try:
+                # Extract OR conditions - now always returns list of lists
+                conditions = extract_or_conditions(query.where)
+                filters = self._build_filters(conditions)
+            except Exception:
+                # Fallback to empty filters
+                filters = {}
 
-            if len(df) > 0:
-                result_df = df[selected_columns]
-        else:
-            # Fetch data without specifying an id
-            page_size = 100  # The page size you want to use for API requests
-            limit = query.limit.value if query.limit else None
-            result_df = pd.DataFrame(columns=selected_columns)
+        # If we got a documentId filter, use the specific endpoint
+        if "documentId" in filters:
+            return self._fetch_by_id(filters["documentId"], selected_columns)
 
-            if limit:
-                # Calculate the number of pages required
-                page_count = (limit + page_size - 1) // page_size
-            else:
-                page_count = 1
+        # Initialize pagination parameters with optimized page size
+        # Use Strapi's default maximum page size of 100 for REST API
+        page_size = 100
+        limit = query.limit.value if query.limit else None
+        result_df = pd.DataFrame(columns=selected_columns)
 
-            for page in range(1, page_count + 1):
-                if limit:
-                    # Calculate the page size for this request
-                    current_page_size = min(page_size, limit)
-                else:
-                    current_page_size = page_size
+        # If limit is specified and smaller than page_size, use limit as page_size to minimize API calls
+        if limit and limit < page_size:
+            page_size = limit
+
+        # Prepare initial parameters including filters
+        params = {
+            "pagination[page]": 1,
+            "pagination[pageSize]": page_size,
+            **filters,  # Add any WHERE clause filters
+        }
+
+        page = 1
+        total_fetched = 0
+
+        # Fetch data in optimized pagination loop
+        while True:
+            params["pagination[page]"] = page
+
+            df = self.handler.call_strapi_api(method="GET", endpoint=f"/api/{self.name}", params=params)
 
-                df = self.handler.call_strapi_api(method='GET', endpoint=f'/api/{self.name}', params={'pagination[page]': page, 'pagination[pageSize]': current_page_size})
+            # Break if no data returned
+            if len(df) == 0:
+                break
 
-                if len(df) == 0:
+            # Apply limit constraint if specified
+            rows_to_take = len(df)
+            if limit:
+                remaining_needed = limit - total_fetched
+                if remaining_needed <= 0:
                     break
+                rows_to_take = min(rows_to_take, remaining_needed)
+
+            # Take only the needed rows and add to result
+            df_slice = df.head(rows_to_take) if rows_to_take < len(df) else df
+            result_df = pd.concat([result_df, df_slice[selected_columns]], ignore_index=True)
 
-                result_df = pd.concat([result_df, df[selected_columns]], ignore_index=True)
+            total_fetched += rows_to_take
 
-                if limit:
-                    limit -= current_page_size
+            # Break conditions:
+            # 1. If we got fewer rows than page_size, we've reached the end
+            # 2. If we have a limit and we've reached it
+            # 3. If we took fewer rows than available due to limit constraint
+            if len(df) < page_size or (limit and total_fetched >= limit) or rows_to_take < len(df):
+                break
+
+            page += 1
 
         return result_df
 
@@ -91,13 +379,23 @@ def insert(self, query: ast.Insert) -> None:
         Args:
             query (ast.Insert): user's entered query
         """
-        data = {'data': {}}
-        for column, value in zip(query.columns, query.values[0]):
-            if isinstance(value, Constant):
-                data['data'][column.name] = value.value
-            else:
-                data['data'][column.name] = value
-        self.handler.call_strapi_api(method='POST', endpoint=f'/api/{self.name}', json_data=json.dumps(data))
+        # Loop through all rows in the VALUES clause
+        for row_values in query.values:
+            data = {"data": {}}
+
+            for column, value in zip(query.columns, row_values):
+                # Clean column name (remove backticks if present)
+                column_name = column.name
+                if column_name.startswith("`") and column_name.endswith("`"):
+                    column_name = column_name[1:-1]
+
+                if isinstance(value, Constant):
+                    data["data"][column_name] = value.value
+                else:
+                    data["data"][column_name] = value
+
+            # Make individual API call for each row
+            self.handler.call_strapi_api(method="POST", endpoint=f"/api/{self.name}", json_data=json.dumps(data))
 
     def update(self, query: ast.Update) -> None:
         """triggered at the UPDATE query
@@ -106,17 +404,19 @@ def update(self, query: ast.Update) -> None:
             query (ast.Update): user's entered query
         """
         conditions = extract_comparison_conditions(query.where)
-        # Get id from query
+        # Get documentId from query
         for op, arg1, arg2 in conditions:
-            if arg1 == 'id' and op == '=':
-                _id = arg2
+            if arg1 == "documentId" and op == "=":
+                _documentId = arg2
             else:
-                raise NotImplementedError
-        data = {'data': {}}
+                raise ValueError("`documentId` must be used in WHERE clause for UPDATE")
+        data = {"data": {}}
         for key, value in query.update_columns.items():
             if isinstance(value, Constant):
-                data['data'][key] = value.value
-        self.handler.call_strapi_api(method='PUT', endpoint=f'/api/{self.name}/{_id}', json_data=json.dumps(data))
+                data["data"][key] = value.value
+        self.handler.call_strapi_api(
+            method="PUT", endpoint=f"/api/{self.name}/{_documentId}", json_data=json.dumps(data)
+        )
 
     def get_columns(self, ignore: List[str] = []) -> List[str]:
         """columns
@@ -127,5 +427,6 @@ def get_columns(self, ignore: List[str] = []) -> List[str]:
         Returns:
             List[str]: available columns with `ignore` items removed from the list.
         """
-
+        if not self._schema_fetched:
+            self._fetch_schema()
         return [item for item in self.columns if item not in ignore]
diff --git a/mindsdb/integrations/handlers/strapi_handler/tests/test_strapi_handler.py b/mindsdb/integrations/handlers/strapi_handler/tests/test_strapi_handler.py
index a7dd95481dc..a2f0b197574 100644
--- a/mindsdb/integrations/handlers/strapi_handler/tests/test_strapi_handler.py
+++ b/mindsdb/integrations/handlers/strapi_handler/tests/test_strapi_handler.py
@@ -1,51 +1,199 @@
 import unittest
+from unittest.mock import patch, Mock
 from mindsdb.integrations.handlers.strapi_handler.strapi_handler import StrapiHandler
+from mindsdb.integrations.handlers.strapi_handler.strapi_tables import extract_or_conditions, StrapiTable
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+from mindsdb_sql_parser import parse_sql
 
 
 class StrapiHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.connection_data = {
+            "host": "localhost",
+            "port": "1337",
+            "api_token": "test_token_123",
+            "endpoints": ["products", "sellers"],
+        }
+        self.handler = StrapiHandler(name="myshop", connection_data=self.connection_data)
 
-    @classmethod
-    def setUpClass(cls):
-        connection_data = {
-            'host': 'localhost',
-            'port': '1337',
-            'api_token': 'c56c000d867e95848c',
-            'plural_api_ids': ['products', 'sellers']}
-        cls.handler = StrapiHandler(name='myshop', connection_data=connection_data)
+        # Mock data for testing (matching real Strapi API response structure)
+        self.mock_products_data = [
+            {
+                "id": 45,
+                "documentId": "mvaprjyy72ayx7z4v592sdnr",
+                "title": "Mens Casual Premium Slim Fit T-Shirts",
+                "desc": "Slim-fitting style, contrast raglan long sleeve, lightweight & breathable fabric.",
+                "price": 22.3,
+                "createdAt": "2025-09-09T08:57:55.574Z",
+                "updatedAt": "2025-09-09T09:53:41.392Z",
+                "publishedAt": "2025-09-09T09:53:41.412Z",
+            },
+            {
+                "id": 46,
+                "documentId": "abc123def456ghi789",
+                "title": "Womens Cotton Jacket",
+                "desc": "Great outerwear for Spring/Autumn/Winter.",
+                "price": 55.99,
+                "createdAt": "2025-09-09T08:58:55.574Z",
+                "updatedAt": "2025-09-09T09:54:41.392Z",
+                "publishedAt": "2025-09-09T09:54:41.412Z",
+            },
+        ]
+
+        self.mock_sellers_data = [
+            {
+                "id": 1,
+                "documentId": "seller123",
+                "name": "Test Seller",
+                "email": "seller@test.com",
+                "sellerid": "seller001",
+                "createdAt": "2025-09-09T08:57:55.574Z",
+                "updatedAt": "2025-09-09T09:53:41.392Z",
+                "publishedAt": "2025-09-09T09:53:41.412Z",
+            }
+        ]
+
+    @patch("mindsdb.integrations.handlers.strapi_handler.strapi_handler.requests.get")
+    def test_0_check_connection(self, mock_get):
+        # Mock successful connection response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"data": {"name": "test-strapi", "version": "4.0.0"}}
+        mock_get.return_value = mock_response
 
-    def test_0_check_connection(self):
         # Ensure the connection is successful
         self.assertTrue(self.handler.check_connection())
 
     def test_1_get_table(self):
-        assert self.handler.get_tables() is not RESPONSE_TYPE.ERROR
+        # Mock the endpoints from connection data
+        result = self.handler.get_tables()
+        self.assertIsNotNone(result)
+        assert result is not RESPONSE_TYPE.ERROR
+
+    @patch("mindsdb.integrations.handlers.strapi_handler.strapi_handler.requests.get")
+    def test_2_get_columns(self, mock_get):
+        # Mock response for schema fetching (single record with limit=1)
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "data": [self.mock_products_data[0]]  # Return first product for schema discovery
+        }
+        mock_get.return_value = mock_response
+
+        result = self.handler.get_columns("products")
+        assert result is not RESPONSE_TYPE.ERROR
+
+    @patch("mindsdb.integrations.handlers.strapi_handler.strapi_handler.requests.get")
+    def test_3_get_data(self, mock_get):
+        # Mock responses: first call for schema (limit=1), second call for actual data
+        schema_response = Mock()
+        schema_response.status_code = 200
+        schema_response.json.return_value = {"data": [self.mock_products_data[0]]}
 
-    def test_2_get_columns(self):
-        assert self.handler.get_columns('products') is not RESPONSE_TYPE.ERROR
+        data_response = Mock()
+        data_response.status_code = 200
+        data_response.json.return_value = {"data": self.mock_products_data}
+
+        # Return schema response first, then data response
+        mock_get.side_effect = [schema_response, data_response]
 
-    def test_3_get_data(self):
         # Ensure that you can retrieve data from a table
-        data = self.handler.native_query('SELECT * FROM products')
+        data = self.handler.native_query("SELECT * FROM products")
         assert data.type is not RESPONSE_TYPE.ERROR
 
-    def test_4_get_data_with_condition(self):
+    @patch("mindsdb.integrations.handlers.strapi_handler.strapi_handler.requests.get")
+    def test_4_get_data_with_condition(self, mock_get):
+        # Mock responses: first call for schema (limit=1), second call for specific documentId
+        schema_response = Mock()
+        schema_response.status_code = 200
+        schema_response.json.return_value = {"data": [self.mock_products_data[0]]}
+
+        specific_response = Mock()
+        specific_response.status_code = 200
+        specific_response.json.return_value = {
+            "data": self.mock_products_data[0]  # Return single product (not in array for specific ID)
+        }
+
+        # Return schema response first, then specific product response
+        mock_get.side_effect = [schema_response, specific_response]
+
         # Ensure that you can retrieve data with a condition
-        data = self.handler.native_query('SELECT * FROM products WHERE id = 1')
+        data = self.handler.native_query("SELECT * FROM products WHERE documentId = 'mvaprjyy72ayx7z4v592sdnr'")
         assert data.type is not RESPONSE_TYPE.ERROR
 
-    def test_5_insert_data(self):
+    @patch("mindsdb.integrations.handlers.strapi_handler.strapi_handler.requests.request")
+    def test_5_insert_data(self, mock_request):
+        # Mock response for successful data insertion
+        mock_response = Mock()
+        mock_response.status_code = 201
+        mock_response.json.return_value = {
+            "data": {
+                "id": 2,
+                "documentId": "newdocid123",
+                "name": "Ram",
+                "email": "ram@gmail.com",
+                "sellerid": "ramu4",
+                "createdAt": "2025-09-09T08:57:55.574Z",
+                "updatedAt": "2025-09-09T09:53:41.392Z",
+                "publishedAt": "2025-09-09T09:53:41.412Z",
+            }
+        }
+        mock_request.return_value = mock_response
+
         # Ensure that data insertion is successful
         query = "INSERT INTO myshop.sellers (name, email, sellerid) VALUES ('Ram', 'ram@gmail.com', 'ramu4')"
         result = self.handler.native_query(query)
-        self.assertTrue(result)
+        self.assertIsNotNone(result)
+        assert result.type is not RESPONSE_TYPE.ERROR
+
+    @patch("mindsdb.integrations.handlers.strapi_handler.strapi_handler.requests.request")
+    def test_6_update_data(self, mock_request):
+        # Mock response for successful data update
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "data": {
+                "id": 45,
+                "documentId": "mvaprjyy72ayx7z4v592sdnr",
+                "title": "Updated Product Title",  # Updated title
+                "desc": "Slim-fitting style, contrast raglan long sleeve, lightweight & breathable fabric.",
+                "price": 22.3,
+                "createdAt": "2025-09-09T08:57:55.574Z",
+                "updatedAt": "2025-09-09T09:53:41.392Z",
+                "publishedAt": "2025-09-09T09:53:41.412Z",
+            }
+        }
+        mock_request.return_value = mock_response
 
-    def test_6_update_data(self):
         # Ensure that data updating is successful
-        query = "UPDATE products SET name = 'test2' WHERE id = 1"
+        query = "UPDATE products SET title = 'Updated Product Title' WHERE documentId = 'mvaprjyy72ayx7z4v592sdnr'"
         result = self.handler.native_query(query)
-        self.assertTrue(result)
+        self.assertIsNotNone(result)
+        assert result.type is not RESPONSE_TYPE.ERROR
+
+    def test_7_where_precedence_or_and(self):
+        query = parse_sql("SELECT * FROM products WHERE a = 1 OR (b = 2 AND c = 4)")
+        table = StrapiTable(handler=self.handler, name="products", defer_schema_fetch=True)
+
+        conditions = extract_or_conditions(query.where)
+        filters = table._build_filters(conditions)
+
+        self.assertIn("filters[$or][0][a][$eq]", filters)
+        self.assertIn("filters[$or][1][$and][0][b][$eq]", filters)
+        self.assertIn("filters[$or][1][$and][1][c][$eq]", filters)
+
+    def test_8_where_precedence_or_or(self):
+        query = parse_sql("SELECT * FROM products WHERE a = 1 OR (b = 2 OR c = 4)")
+        table = StrapiTable(handler=self.handler, name="products", defer_schema_fetch=True)
+
+        conditions = extract_or_conditions(query.where)
+        filters = table._build_filters(conditions)
+
+        self.assertIn("filters[$or][0][a][$eq]", filters)
+        self.assertIn("filters[$or][1][b][$eq]", filters)
+        self.assertIn("filters[$or][2][c][$eq]", filters)
+        self.assertFalse(any("[$and]" in key for key in filters))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()
diff --git a/mindsdb/integrations/libs/base.py b/mindsdb/integrations/libs/base.py
index 9f7dbe618ff..2757b7ba594 100644
--- a/mindsdb/integrations/libs/base.py
+++ b/mindsdb/integrations/libs/base.py
@@ -1,15 +1,23 @@
 import ast
 import concurrent.futures
+import functools
 import inspect
 import textwrap
 from _ast import AnnAssign, AugAssign
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, get_type_hints, get_args, Union, get_origin
 
 import pandas as pd
 from mindsdb_sql_parser.ast.base import ASTNode
 from mindsdb.utilities import log
 
-from mindsdb.integrations.libs.response import HandlerResponse, HandlerStatusResponse, RESPONSE_TYPE
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse,
+    RESPONSE_TYPE,
+    DataHandlerResponse,
+    normalize_response,
+    ErrorResponse,
+    TableResponse,
+)
 
 logger = log.getLogger(__name__)
 
@@ -21,6 +29,59 @@ class BaseHandler:
     broader MindsDB ecosystem via SQL commands.
     """
 
+    stream_response = False
+
+    def __init_subclass__(cls, **kwargs):
+        """Automatically wrap handler methods to normalize their responses.
+
+        When a subclass is defined, this method checks if any of the methods
+        in _methods_to_normalize are overridden and wraps them to convert
+        legacy HandlerResponse to new response types (TableResponse, OkResponse,
+        ErrorResponse).
+        """
+        super().__init_subclass__(**kwargs)
+
+        # Methods whose return values should be normalized to new response types
+        _methods_to_normalize = (
+            "native_query",
+            "query",
+            "insert",
+            "get_tables",
+            "get_columns",
+            "meta_get_tables",
+            "meta_get_columns",
+            "meta_get_column_statistics",
+            "meta_get_column_statistics_for_table",
+            "meta_get_primary_keys",
+            "meta_get_foreign_keys",
+        )
+        for method_name in _methods_to_normalize:
+            # Only wrap if method is defined directly in this class (not inherited)
+            if method_name not in cls.__dict__:
+                continue
+
+            original_method = cls.__dict__[method_name]
+
+            return_type = get_type_hints(original_method).get("return")
+            if return_type is DataHandlerResponse or (
+                get_origin(return_type) is Union and issubclass(get_args(return_type)[0], DataHandlerResponse)
+            ):
+                # this is already new style response
+                continue
+
+            # Skip if already wrapped
+            if getattr(original_method, "_response_normalized", False):
+                continue
+
+            # Create wrapper that normalizes response
+            @functools.wraps(original_method)
+            def wrapper(self, *args, _orig=original_method, **kwargs):
+                result = _orig(self, *args, **kwargs)
+                return normalize_response(result)
+
+            wrapper._response_normalized = True
+            setattr(cls, method_name, wrapper)
+
     def __init__(self, name: str):
         """constructor
         Args:
@@ -53,19 +114,19 @@ def check_connection(self) -> HandlerStatusResponse:
         """
         raise NotImplementedError()
 
-    def native_query(self, query: Any) -> HandlerResponse:
+    def native_query(self, query: Any, stream: bool = False, **kwargs) -> DataHandlerResponse:
         """Receive raw query and act upon it somehow.
 
         Args:
-            query (Any): query in native format (str for sql databases,
-                etc)
-
+            query (Any): query in native format (str for sql databases, etc)
+            stream (bool): Whether to stream the results of the query
+            **kwargs: Additional keyword arguments.
         Returns:
-            HandlerResponse
+            DataHandlerResponse
         """
         raise NotImplementedError()
 
-    def query(self, query: ASTNode) -> HandlerResponse:
+    def query(self, query: ASTNode) -> DataHandlerResponse:
         """Receive query as AST (abstract syntax tree) and act upon it somehow.
 
         Args:
@@ -73,30 +134,30 @@ def query(self, query: ASTNode) -> HandlerResponse:
                 of query: SELECT, INSERT, DELETE, etc
 
         Returns:
-            HandlerResponse
+            DataHandlerResponse
         """
         raise NotImplementedError()
 
-    def get_tables(self) -> HandlerResponse:
+    def get_tables(self) -> DataHandlerResponse:
         """Return list of entities
 
         Return list of entities that will be accesible as tables.
 
         Returns:
-            HandlerResponse: shoud have same columns as information_schema.tables
+            DataHandlerResponse: shoud have same columns as information_schema.tables
                 (https://dev.mysql.com/doc/refman/8.0/en/information-schema-tables-table.html)
                 Column 'TABLE_NAME' is mandatory, other is optional.
         """
         raise NotImplementedError()
 
-    def get_columns(self, table_name: str) -> HandlerResponse:
+    def get_columns(self, table_name: str) -> DataHandlerResponse:
         """Returns a list of entity columns
 
         Args:
             table_name (str): name of one of tables returned by self.get_tables()
 
         Returns:
-            HandlerResponse: shoud have same columns as information_schema.columns
+            DataHandlerResponse: shoud have same columns as information_schema.columns
                 (https://dev.mysql.com/doc/refman/8.0/en/information-schema-columns-table.html)
                 Column 'COLUMN_NAME' is mandatory, other is optional. Hightly
                 recomended to define also 'DATA_TYPE': it should be one of
@@ -125,12 +186,12 @@ class MetaDatabaseHandler(DatabaseHandler):
     def __init__(self, name: str):
         super().__init__(name)
 
-    def meta_get_tables(self, table_names: Optional[List[str]]) -> HandlerResponse:
+    def meta_get_tables(self, table_names: Optional[List[str]]) -> DataHandlerResponse:
         """
         Returns metadata information about the tables to be stored in the data catalog.
 
         Returns:
-            HandlerResponse: The response should consist of the following columns:
+            DataHandlerResponse: The response should consist of the following columns:
             - TABLE_NAME (str): Name of the table.
             - TABLE_TYPE (str): Type of the table, e.g. 'BASE TABLE', 'VIEW', etc. (optional).
             - TABLE_SCHEMA (str): Schema of the table (optional).
@@ -139,12 +200,12 @@ def meta_get_tables(self, table_names: Optional[List[str]]) -> HandlerResponse:
         """
         raise NotImplementedError()
 
-    def meta_get_columns(self, table_names: Optional[List[str]]) -> HandlerResponse:
+    def meta_get_columns(self, table_names: Optional[List[str]]) -> DataHandlerResponse:
         """
         Returns metadata information about the columns in the tables to be stored in the data catalog.
 
         Returns:
-            HandlerResponse: The response should consist of the following columns:
+            DataHandlerResponse: The response should consist of the following columns:
             - TABLE_NAME (str): Name of the table.
             - COLUMN_NAME (str): Name of the column.
             - DATA_TYPE (str): Data type of the column, e.g. 'VARCHAR', 'INT', etc.
@@ -154,13 +215,13 @@ def meta_get_columns(self, table_names: Optional[List[str]]) -> HandlerResponse:
         """
         raise NotImplementedError()
 
-    def meta_get_column_statistics(self, table_names: Optional[List[str]]) -> HandlerResponse:
+    def meta_get_column_statistics(self, table_names: Optional[List[str]]) -> DataHandlerResponse:
         """
         Returns metadata statisical information about the columns in the tables to be stored in the data catalog.
         Either this method should be overridden in the handler or `meta_get_column_statistics_for_table` should be implemented.
 
         Returns:
-            HandlerResponse: The response should consist of the following columns:
+            DataHandlerResponse: The response should consist of the following columns:
             - TABLE_NAME (str): Name of the table.
             - COLUMN_NAME (str): Name of the column.
             - MOST_COMMON_VALUES (List[str]): Most common values in the column (optional).
@@ -207,17 +268,14 @@ def meta_get_column_statistics(self, table_names: Optional[List[str]]) -> Handle
 
             if not results:
                 logger.warning("No column statistics could be retrieved for the specified tables.")
-                return HandlerResponse(RESPONSE_TYPE.ERROR, error_message="No column statistics could be retrieved.")
-            return HandlerResponse(
-                RESPONSE_TYPE.TABLE, pd.concat(results, ignore_index=True) if results else pd.DataFrame()
-            )
-
+                return ErrorResponse(error_message="No column statistics could be retrieved.")
+            return TableResponse(data=pd.concat(results, ignore_index=True) if results else pd.DataFrame())
         else:
             raise NotImplementedError()
 
     def meta_get_column_statistics_for_table(
         self, table_name: str, column_names: Optional[List[str]] = None
-    ) -> HandlerResponse:
+    ) -> DataHandlerResponse:
         """
         Returns metadata statistical information about the columns in a specific table to be stored in the data catalog.
         Either this method should be implemented in the handler or `meta_get_column_statistics` should be overridden.
@@ -227,7 +285,7 @@ def meta_get_column_statistics_for_table(
             column_names (Optional[List[str]]): List of column names to retrieve statistics for. If None, statistics for all columns will be returned.
 
         Returns:
-            HandlerResponse: The response should consist of the following columns:
+            DataHandlerResponse: The response should consist of the following columns:
             - TABLE_NAME (str): Name of the table.
             - COLUMN_NAME (str): Name of the column.
             - MOST_COMMON_VALUES (List[str]): Most common values in the column (optional).
@@ -239,12 +297,12 @@ def meta_get_column_statistics_for_table(
         """
         pass
 
-    def meta_get_primary_keys(self, table_names: Optional[List[str]]) -> HandlerResponse:
+    def meta_get_primary_keys(self, table_names: Optional[List[str]]) -> DataHandlerResponse:
         """
         Returns metadata information about the primary keys in the tables to be stored in the data catalog.
 
         Returns:
-            HandlerResponse: The response should consist of the following columns:
+            DataHandlerResponse: The response should consist of the following columns:
             - TABLE_NAME (str): Name of the table.
             - COLUMN_NAME (str): Name of the column that is part of the primary key.
             - ORDINAL_POSITION (int): Position of the column in the primary key (optional).
@@ -252,12 +310,12 @@ def meta_get_primary_keys(self, table_names: Optional[List[str]]) -> HandlerResp
         """
         raise NotImplementedError()
 
-    def meta_get_foreign_keys(self, table_names: Optional[List[str]]) -> HandlerResponse:
+    def meta_get_foreign_keys(self, table_names: Optional[List[str]]) -> DataHandlerResponse:
         """
         Returns metadata information about the foreign keys in the tables to be stored in the data catalog.
 
         Returns:
-            HandlerResponse: The response should consist of the following columns:
+            DataHandlerResponse: The response should consist of the following columns:
             - PARENT_TABLE_NAME (str): Name of the parent table.
             - PARENT_COLUMN_NAME (str): Name of the parent column that is part of the foreign key.
             - CHILD_TABLE_NAME (str): Name of the child table.
diff --git a/mindsdb/integrations/libs/const.py b/mindsdb/integrations/libs/const.py
index 0e5ccc23c32..01749c4ce0a 100644
--- a/mindsdb/integrations/libs/const.py
+++ b/mindsdb/integrations/libs/const.py
@@ -16,6 +16,7 @@ class HANDLER_CONNECTION_ARG_TYPE:
     PATH = "path"
     DICT = "dict"
     PWD = "pwd"
+    LIST = "list"
 
 
 HANDLER_CONNECTION_ARG_TYPE = HANDLER_CONNECTION_ARG_TYPE()
diff --git a/mindsdb/integrations/libs/keyword_search_base.py b/mindsdb/integrations/libs/keyword_search_base.py
index 6a1cfdd9b80..d515764ba2a 100644
--- a/mindsdb/integrations/libs/keyword_search_base.py
+++ b/mindsdb/integrations/libs/keyword_search_base.py
@@ -36,6 +36,6 @@ def keyword_select(
             conditions (List[FilterCondition]): conditions to select
 
         Returns:
-            HandlerResponse
+            pd.DataFrame
         """
         raise NotImplementedError()
diff --git a/mindsdb/integrations/libs/llm/utils.py b/mindsdb/integrations/libs/llm/utils.py
index dcf80dd425a..da01454142e 100644
--- a/mindsdb/integrations/libs/llm/utils.py
+++ b/mindsdb/integrations/libs/llm/utils.py
@@ -1,8 +1,5 @@
 import re
-import json
-import itertools
-from enum import Enum
-from typing import Optional, Dict, List, Tuple
+from typing import Dict, List, Tuple
 
 import numpy as np
 import pandas as pd
@@ -20,23 +17,6 @@
     BedrockConfig,
 )
 from mindsdb.utilities.config import config
-from mindsdb.integrations.utilities.rag.splitters.custom_splitters import RecursiveCharacterTextSplitter
-
-
-class Language(Enum):
-    PYTHON = "python"
-    JAVASCRIPT = "javascript"
-    TYPESCRIPT = "typescript"
-    JAVA = "java"
-    CPP = "cpp"
-    C = "c"
-    GO = "go"
-    RUST = "rust"
-    RUBY = "ruby"
-    PHP = "php"
-    SWIFT = "swift"
-    KOTLIN = "kotlin"
-    SCALA = "scala"
 
 
 # Default to latest GPT-4 model (https://platform.openai.com/docs/models/gpt-4-and-gpt-4-turbo)
@@ -256,357 +236,3 @@ def get_llm_config(provider: str, args: Dict) -> BaseLLMConfig:
         )
 
     raise ValueError(f"Provider {provider} is not supported.")
-
-
-def ft_jsonl_validation(
-    items: list,  # read from a JSONL file
-    messages_col: str = "messages",
-    # valid keys for each chat message
-    role_key: str = "role",
-    content_key: str = "content",
-    name_key: str = "name",
-    # valid roles for each chat message
-    system_key: str = "system",
-    user_key: str = "user",
-    assistant_key: str = "assistant",
-):
-    """
-    This helper checks a list of dictionaries for compliance with the format usually expected by LLM providers
-    (such as OpenAI or AnyscaleEndpoints) for fine-tuning LLMs that generate chat completions.
-
-    Defaults are set according to the expected format, but these can be changed if needed by any given provider.
-
-    :param items: list of JSON lines, each dictionary containing a chat sequence. Should be read from a JSONL file.
-    :param messages_col: key in each dictionary to access a sequence of chat messages
-
-
-    For chat-level checks, this method defers to `ft_chat_format_validation()` below. Relevant parameters for it are:
-
-    For each chat:
-    :param role_key: key that defines the role of each message (e.g. system, user, or LLM)
-    :param content_key: key that defines the content of each message
-    :param name_key: key that defines the name of each message
-
-    For each message:
-    :param system_key: valid role for each chat message
-    :param user_key: valid role for each chat message
-    :param assistant_key: valid role for each chat message
-
-    :return: None, raises an Exception if validation fails.
-    """  # noqa
-    try:
-        if not all([isinstance(m, dict) for m in items]):
-            raise Exception("Each line in the provided data should be a dictionary")
-
-        for line_num, batch in enumerate(items):
-            prefix = f"error in chat #{line_num + 1}, "
-
-            if not isinstance(batch[messages_col], list):
-                raise Exception(
-                    f"{prefix}Each line in the provided data should have a '{messages_col}' key with a list of messages"
-                )  # noqa
-
-            if messages_col not in batch:
-                raise Exception(f"{prefix}Each line in the provided data should have a '{messages_col}' key")
-
-            messages = batch[messages_col]
-            try:
-                ft_chat_format_validation(
-                    messages,
-                    role_key=role_key,
-                    content_key=content_key,
-                    name_key=name_key,
-                    system_key=system_key,
-                    user_key=user_key,
-                    assistant_key=assistant_key,
-                )
-            except Exception as e:
-                raise Exception(f"{prefix}{e}") from e
-
-    except Exception as e:
-        raise Exception(f"Fine-tuning data format is not valid. Got {e}") from e
-
-
-def ft_chat_format_validation(
-    chat: list,
-    transitions: Optional[Dict] = None,
-    system_key: str = "system",
-    user_key: str = "user",
-    assistant_key: str = "assistant",
-    role_key: str = "role",
-    content_key: str = "content",
-    name_key: str = "name",
-):
-    """
-    Finite state machine to check a chat has valid format to finetune an LLM with it.
-    Follows OpenAI ChatCompletion format (also used by other providers such as AnyscaleEndpoints).
-    Reference: https://cookbook.openai.com/examples/chat_finetuning_data_prep
-
-    The unit test in `test_llm_utils.py` for examples of valid and invalid chats.
-
-    :param chat: list of dictionaries, each containing a chat message
-    :param transitions: optional dictionary defining valid transitions between chat messages (e.g. from system to user to assistant)
-
-    For each chat:
-    :param role_key: key that defines the role of each message (e.g. system, user, or LLM)
-    :param content_key: key that defines the content of each message
-    :param name_key: key that defines the name of each message
-
-    For each message:
-    :param system_key: valid role for each chat message
-    :param user_key: valid role for each chat message
-    :param assistant_key: valid role for each chat message
-
-    :return: None if chat is valid, otherwise raise an informative Exception.
-    """  # noqa
-
-    valid_keys = (role_key, content_key, name_key)
-    valid_roles = (system_key, user_key, assistant_key)
-
-    for c in chat:
-        if any(k not in valid_keys for k in c.keys()):
-            raise Exception(f"Each message should only have these keys: `{valid_keys}`. Found: `{c.keys()}`")
-
-    roles = [m[role_key] for m in chat]
-    contents = [m[content_key] for m in chat]
-
-    if len(roles) != len(contents):
-        raise Exception(f"Each message should contain both `{role_key}` and `{content_key}` fields")
-
-    if len(roles) == 0:
-        raise Exception("Chat should have at least one message")
-
-    if assistant_key not in roles:
-        raise Exception("Chat should have at least one assistant message")  # otherwise it is useless for FT
-
-    if user_key not in roles:
-        raise Exception("Chat should have at least one user message")  # perhaps remove in the future
-
-    # set default transitions for finite state machine if undefined
-    if transitions is None:
-        transitions = {
-            None: [system_key, user_key],
-            system_key: [user_key],
-            user_key: [assistant_key],
-            assistant_key: [user_key],
-        }
-
-    # check order is valid via finite state machine
-    state = None
-    for i, (role, content) in enumerate(zip(roles, contents)):
-        prefix = f"message #{i + 1}: "
-
-        # check invalid roles
-        if role not in valid_roles:
-            raise Exception(f"{prefix}Invalid role (found `{role}`, expected one of `{valid_roles}`)")
-
-        # check content
-        if not isinstance(content, str):
-            raise Exception(f"{prefix}Content should be a string, got type `{type(content)}`")
-
-        # check transition
-        if role not in transitions[state]:
-            raise Exception(f"{prefix}Invalid transition from `{state}` to `{role}`")
-        else:
-            state = role
-
-
-def ft_formatter(df: pd.DataFrame) -> List[Dict]:
-    """
-    Data preparation entry point for chat LLM finetuning. This method will dispatch to the appropriate formatters.
-
-    Supported formats:
-        - code: long tabular format with a `code` column
-        - chat: long tabular format with `role` and `content` columns, or a JSON format with a `chat_json` column.
-    """
-    if "code" in df.columns:
-        df = ft_code_formatter(df)
-
-    elif {"question", "context", "answer"}.issubset(set(df.columns)):
-        # TODO: handler user-specified names for these columns
-        df = ft_cqa_formatter(df)
-
-    return ft_chat_formatter(df)
-
-
-def ft_chat_formatter(df: pd.DataFrame) -> List[Dict]:
-    """
-    For more details, check `FineTuning -> Data Format` in the Anyscale API reference, or the OpenAI equivalent.
-    Additionally, the unit test in `test_llm_utils.py` provides example usage.
-
-    :param df: input dataframe has chats in one of the following formats:
-        1) long tabular: at least two columns, `role` and `content`. Rows contain >= 1 chats in long (stacked) format.
-
-        2) JSON: at least one column, `chat_json`. Each row contains exactly 1 chat in JSON format.
-            Example for `chat_json` content:
-                > `{"messages": [{"role": "user", "content": "Hello!"}, {"role": "assistant", "content": "Hi!"}]}`
-
-    Optional df columns are:
-        - chat_id: unique identifier for each chat
-        - message_id: unique identifier for each message within each chat
-
-        Data will be sorted by both if they are provided.
-
-        If only `chat_id` is provided, data will be sorted by it with a stable sort, so messages for each chat
-        will be in the same order as in the original data.
-
-        If only `message_id` is provided, it must not contain duplicate IDs. Entire dataset will be treated
-        as a single chat. Otherwise an exception will be raised.
-
-    :return: list of chats. Each chat is a dictionary with a top level key 'messages' containing a list of messages
-    that comply with the OpenAI's ChatEndpoint expected format (i.e., each is a dictionary with a `role` and
-    `content` key.
-
-    """  # noqa
-    # 1. pre-sort df on optional columns
-    if "chat_id" in df.columns:
-        if "message_id" in df.columns:
-            df = df.sort_values(["chat_id", "message_id"])
-        else:
-            df = df.sort_values(["chat_id"], kind="stable")
-    elif "message_id" in df.columns:
-        if df["message_id"].duplicated().any():
-            raise Exception("If `message_id` is provided, it must not contain duplicate IDs.")
-        df = df.sort_values(["message_id"])
-
-    # 2. build chats
-    chats = []
-
-    # 2a. chats are in JSON format
-    if "chat_json" in df.columns:
-        for _, row in df.iterrows():
-            try:
-                chat = json.loads(row["chat_json"])
-                assert list(chat.keys()) == ["messages"], "Each chat should have a 'messages' key, and nothing else."
-                ft_chat_format_validation(chat["messages"])  # will raise Exception if chat is invalid
-                chats.append(chat)
-            except json.JSONDecodeError:
-                pass  # TODO: add logger info here, prompt user to clean dataset carefully
-
-    # 2b. chats are in tabular format - aggregate each chat sequence into one row
-    else:
-        chat = []
-        for i, row in df.iterrows():
-            if row["role"] == "system" and len(chat) > 0:
-                ft_chat_format_validation(chat)  # will raise Exception if chat is invalid
-                chats.append({"messages": chat})
-                chat = []
-            event = {"role": row["role"], "content": row["content"]}
-            chat.append(event)
-
-        ft_chat_format_validation(chat)  # will raise Exception if chat is invalid
-        chats.append({"messages": chat})
-
-    return chats
-
-
-def ft_code_formatter(
-    df: pd.DataFrame,
-    format="chat",
-    language="python",
-    chunk_size=100,
-    chunk_overlap=0,
-    chat_sections=("Code prefix", "Code suffix", "Completion"),
-    fim_tokens=("<PRE>", "<SUF>", "<MID>"),
-) -> pd.DataFrame:
-    """
-    This utility processes a raw codebase stored as a dataframe with a `code` column, where
-    every row may be an entire file or some portion of it.
-    It chunks code into triples made of a prefix, middle, and suffix.
-
-    Depending on the target LLM, these triples are then formatted into a chat-like prompt, or a
-    fill-in-the-middle (FIM) prompt. The latter is used for fine-tuning models like codellama,
-    while the former is more generic and should work with any LLM that supports the ChatCompletion
-    format, as the rest of our tools do.
-    """
-
-    # input and setup validation
-    assert len(df) > 0, "Input dataframe should not be empty"
-    assert "code" in df.columns, "Input dataframe should have a 'code' column"
-    assert chunk_size > 0 and isinstance(chunk_size, int), "`chunk_size` should be a positive integer"
-
-    supported_formats = ["chat", "fim"]
-    supported_langs = [e.value for e in Language]
-    assert language.lower() in supported_langs, f"Invalid language. Valid choices are: {supported_langs}"
-
-    # ensure correct encoding
-    df["code"] = df["code"].map(lambda x: x.encode("utf8").decode("unicode_escape"))
-
-    # set prompt templates
-    system_prompt = "You are a powerful text to code model. Your job is to provide great code completions. As context, you are given code that is found immediately before and after the code you must generate.\n\nYou must output the code that should go in between the prefix and suffix.\n\n"
-    if format == "chat":
-        templates = [f"### {c}:" for c in chat_sections]
-    elif format == "fim":
-        templates = fim_tokens
-    else:
-        raise Exception(f"Invalid format. Please choose one of {supported_formats}")
-
-    # split code into chunks
-    # Get language enum value (handle both string and enum)
-    lang_enum = getattr(Language, language.upper(), language)
-    code_splitter = RecursiveCharacterTextSplitter.from_language(
-        language=lang_enum,
-        chunk_size=3 * chunk_size,  # each triplet element has `chunk_size`
-        chunk_overlap=chunk_overlap,  # some overlap here is fine
-    )
-    chunk_docs = code_splitter.create_documents(list(df["code"]))
-    chunks = [c.page_content for c in chunk_docs]
-
-    # split each chunk into a triplet, with no overlap
-    triplet_splitter = RecursiveCharacterTextSplitter.from_language(
-        language=lang_enum,
-        chunk_size=chunk_size,
-        chunk_overlap=0,  # no overlap admitted, otherwise context may leak into answer
-    )
-    triplet_chunk_docs = triplet_splitter.create_documents(chunks)
-    chunks = [c.page_content for c in triplet_chunk_docs]
-    chunks = chunks[: len(chunks) - len(chunks) % 3]  # should be a multiple of 3
-
-    # format chunks into prompts
-    roles = []
-    contents = []
-    for idx in range(0, len(chunks), 3):
-        pre, mid, suf = chunks[idx : idx + 3]
-        interleaved = list(itertools.chain(*zip(templates, (pre, suf, mid))))
-        user = "\n".join(interleaved[:-1])
-        assistant = "\n".join(interleaved[-1:])
-        roles.extend(["system", "user", "assistant"])
-        contents.extend([system_prompt, user, assistant])
-
-    # return formatted prompts in a dataframe to be processed by `ft_chat_formatter()`
-    df = pd.DataFrame({"role": roles, "content": contents})
-    return df
-
-
-def ft_cqa_formatter(
-    df: pd.DataFrame,
-    question_col="question",
-    answer_col="answer",
-    instruction_col="instruction",
-    context_col="context",
-    default_instruction="You are a helpful assistant.",
-    default_context="",
-) -> pd.DataFrame:
-    # input and setup validation
-    assert len(df) > 0, "Input dataframe should not be empty"
-    assert {question_col, answer_col}.issubset(set(df.columns)), (
-        f"Input dataframe must have columns `{question_col}`, and `{answer_col}`"
-    )  # noqa
-
-    if instruction_col not in df.columns:
-        df[instruction_col] = default_instruction
-
-    if context_col not in df.columns:
-        df[context_col] = default_context
-
-    # format data into chat-like prompts
-    roles = []
-    contents = []
-    for i, row in df.iterrows():
-        system = "\n".join([row[instruction_col], row[context_col]])
-        user = row[question_col]
-        assistant = row[answer_col]
-        roles.extend(["system", "user", "assistant"])
-        contents.extend([system, user, assistant])
-
-    return pd.DataFrame({"role": roles, "content": contents})
diff --git a/mindsdb/integrations/libs/ml_exec_base.py b/mindsdb/integrations/libs/ml_exec_base.py
index 96eca4a033a..abac27d75de 100644
--- a/mindsdb/integrations/libs/ml_exec_base.py
+++ b/mindsdb/integrations/libs/ml_exec_base.py
@@ -7,7 +7,7 @@
       normally associated with a DB handler (e.g. `native_query`, `get_tables`), as well as other ML-specific behaviors,
       like `learn()` or `predict()`. Note that while these still have to be implemented at the engine level, the burden
       on that class is lesser given that it only needs to return a pandas DataFrame. It's this class that will take said
-      output and format it into the HandlerResponse instance that MindsDB core expects.
+      output and format it into the DataHandlerResponse instance that MindsDB core expects.
 
     - `learn_process` method: handles async dispatch of the `learn` method in an engine, as well as registering all
       models inside of the internal MindsDB registry.
diff --git a/mindsdb/integrations/libs/response.py b/mindsdb/integrations/libs/response.py
index aa39ce4c2c6..3af33b444fa 100644
--- a/mindsdb/integrations/libs/response.py
+++ b/mindsdb/integrations/libs/response.py
@@ -1,14 +1,17 @@
 import sys
-from typing import Callable
+from abc import ABC
+from typing import Callable, Generator, ClassVar
 from dataclasses import dataclass, fields
 
 import numpy
 import pandas
+import psutil
 
 from mindsdb.utilities import log
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 from mindsdb_sql_parser.ast import ASTNode
+from mindsdb.utilities.types.column import Column
 
 
 logger = log.getLogger(__name__)
@@ -40,7 +43,464 @@ class _INFORMATION_SCHEMA_COLUMNS_NAMES:
 INF_SCHEMA_COLUMNS_NAMES_SET = set(f.name for f in fields(INF_SCHEMA_COLUMNS_NAMES))
 
 
+class HandlerStatusResponse:
+    def __init__(
+        self,
+        success: bool = True,
+        error_message: str = None,
+        redirect_url: str = None,
+        copy_storage: str = None,
+    ) -> None:
+        self.success = success
+        self.error_message = error_message
+        self.redirect_url = redirect_url
+        self.copy_storage = copy_storage
+
+    def to_json(self):
+        data = {"success": self.success, "error": self.error_message}
+        if self.redirect_url is not None:
+            data["redirect_url"] = self.redirect_url
+        if self.copy_storage is not None:
+            data["copy_storage"] = self.copy_storage
+        return data
+
+    def __repr__(self):
+        return (
+            f"{self.__class__.__name__}("
+            f"success={self.success}, "
+            f"error={self.error_message}, "
+            f"redirect_url={self.redirect_url}, "
+            f"copy_storage={self.copy_storage})"
+        )
+
+
+class DataHandlerResponse(ABC):
+    """Base class for all data handler responses."""
+
+    type: ClassVar[str]
+
+    @property
+    def resp_type(self):
+        # For back compatibility with old code, use the type attribute instead of resp_type
+        return self.type
+
+
+class ErrorResponse(DataHandlerResponse):
+    """Response for error cases.
+
+    Attributes:
+        type: RESPONSE_TYPE.ERROR
+        error_code: int
+        error_message: str | None
+        is_expected_error: bool
+        exception: Exception | None
+    """
+
+    type: ClassVar[str] = RESPONSE_TYPE.ERROR
+    error_code: int
+    error_message: str | None
+    is_expected_error: bool
+    exception: Exception | None
+
+    def __init__(self, error_code: int = 0, error_message: str | None = None, is_expected_error: bool = False):
+        self.error_code = error_code
+        self.error_message = error_message
+        self.is_expected_error = is_expected_error
+        self.exception = None
+        current_exception = sys.exc_info()
+        if current_exception[0] is not None:
+            self.exception = current_exception[1]
+
+    def to_columns_table_response(self, map_type_fn: Callable) -> None:
+        raise ValueError(
+            f"Cannot convert {self.type} to {RESPONSE_TYPE.COLUMNS_TABLE}, the error is: {self.error_message}"
+        )
+
+
+class OkResponse(DataHandlerResponse):
+    """Response for successful cases without data (e.g. CREATE TABLE, DROP TABLE, etc.).
+
+    Attributes:
+        type: RESPONSE_TYPE.OK
+        affected_rows: int - how many rows were affected by the query
+    """
+
+    type: ClassVar[str] = RESPONSE_TYPE.OK
+    affected_rows: int
+
+    def __init__(self, affected_rows: int = None):
+        self.affected_rows = affected_rows
+
+
+def _safe_pandas_concat(pieces: list[pandas.DataFrame]) -> pandas.DataFrame:
+    """Safely concatenates multiple pandas DataFrames while checking available memory.
+    If the estimated memory required for concatenation (with a safety multiplier of 2.5x)
+    exceeds the available memory, it raises a MemoryError.
+
+    Args:
+        pieces (list[pandas.DataFrame]): A list of pandas DataFrames to concatenate.
+
+    Returns:
+        pandas.DataFrame: The concatenated DataFrame.
+
+    Raises:
+        MemoryError: If there is insufficient memory to perform the concatenation safely.
+    """
+    if len(pieces) == 1:
+        return pieces[0]
+    available_memory_kb = psutil.virtual_memory().available >> 10
+    pieces_size_kb = sum([(x.memory_usage(index=True, deep=True).sum() >> 10) for x in pieces])
+    if (pieces_size_kb * 2.5) > available_memory_kb:
+        raise MemoryError()
+    return pandas.concat(pieces)
+
+
+class TableResponse(DataHandlerResponse):
+    """Response for successful cases with data (e.g. SELECT, SHOW, etc.).
+
+    Attributes:
+        type: RESPONSE_TYPE.TABLE | RESPONSE_TYPE.COLUMNS_TABLE - type of data in the response
+        affected_rows: int | None - how many rows were affected by the query
+        data_generator: Generator[pandas.DataFrame, None, None] | None - generator of data for lazy loading
+        _columns: list[Column] | None - list of columns
+        _data: pandas.DataFrame | None - loaded data
+        _fetched: bool - if data was already fetched (data_generator is consumed)
+        _invalid: bool - if data has already been fetched and cannot be iterated over
+        _last_data_piece: pandas.DataFrame | None - last data piece fetched
+        rows_fetched: int - how many rows were fetched
+    """
+
+    type: str
+    affected_rows: int | None
+    _data_generator: Generator[pandas.DataFrame, None, None] | None
+    _columns: list[Column] | None
+    _data: pandas.DataFrame | None
+    _fetched: bool
+    _invalid: bool
+    _last_data_piece: pandas.DataFrame | None
+    rows_fetched: int
+
+    def __init__(
+        self,
+        data: pandas.DataFrame | None = None,
+        data_generator: Generator[pandas.DataFrame, None, None] | None = None,
+        affected_rows: int | None = None,
+        columns: list[Column] = None,
+    ):
+        """
+        Either data and/or data_generator must be provided.
+        Args:
+            data (pandas.DataFrame): initial data
+            data_generator (Generator[pandas.DataFrame, None, None]): generator of data
+            affected_rows (int): total data rowcount - can be None depending on the handler
+                                 NOTE: name affected_rows for compatibility with OKResponse
+            columns (list[Column]): list of columns
+        """
+        self.type = RESPONSE_TYPE.TABLE
+        self._data_generator = data_generator
+        self._columns = columns
+        self.affected_rows = affected_rows
+        self._data = data
+        self._fetched = False if data_generator else True
+        self._invalid = False
+        self._last_data_piece = None
+        self.rows_fetched = len(data) if data is not None else 0
+
+    @property
+    def data_generator(self) -> Generator[pandas.DataFrame, None, None]:
+        return self._data_generator
+
+    @data_generator.setter
+    def data_generator(self, value):
+        self._fetched = False if value else True
+        self._data_generator = value
+
+    def fetchall(self) -> pandas.DataFrame:
+        """Fetch all data and store it in the _data attribute.
+
+        Returns:
+            pandas.DataFrame: Data frame.
+        """
+        self._raise_if_invalid()
+        if self._data_generator is None or self._fetched:
+            return self._data
+
+        pieces = list(self._iterate_with_memory_check())
+        if self._data is None:
+            if len(pieces) == 1:
+                self._data = pieces[0]
+            elif len(pieces) == 0:
+                self._data = pandas.DataFrame([], columns=[column.name for column in self._columns])
+            else:
+                self._data = _safe_pandas_concat(pieces)
+        elif len(pieces) > 0:
+            self._data = _safe_pandas_concat([self._data, *pieces])
+
+        self._fetched = True
+        self._data_generator = None
+
+        return self._data
+
+    def _raise_if_low_memory(self) -> None:
+        """Check if there is enough available memory to load the next data chunk.
+
+        Estimates the memory required for the next chunk based on the size of the last
+        fetched chunk. If `affected_rows` (fetched rows) is known, the estimate is capped at the
+        number of remaining rows (but no more than one chunk). Otherwise, assumes the next chunk will
+        be the same size as the previous one.
+
+        Does nothing when no data has been fetched yet.
+
+        Raises:
+            MemoryError: If estimated memory for the next chunk exceeds available memory.
+        """
+        if self._last_data_piece is None or len(self._last_data_piece) == 0:
+            return
+
+        data_piece_size_kb = self._last_data_piece.memory_usage(index=True, deep=True).sum() >> 10
+        if isinstance(self.affected_rows, int) and self.affected_rows > 0:
+            row_size_kb = data_piece_size_kb / len(self._last_data_piece)
+            rows_expected = min(self.affected_rows - self.rows_fetched, len(self._last_data_piece))
+            if rows_expected > 0:
+                available_memory_kb = psutil.virtual_memory().available >> 10
+                if available_memory_kb < (row_size_kb * rows_expected * 1.1):
+                    raise MemoryError(
+                        f"Not enough memory to load remaining data. "
+                        f"Available: {available_memory_kb}KB, estimated need: {int(row_size_kb * rows_expected * 1.1)}KB"
+                    )
+        else:
+            # assume that next piece is the same size
+            available_memory_kb = psutil.virtual_memory().available >> 10
+            if available_memory_kb < (data_piece_size_kb * 1.1):
+                raise MemoryError(
+                    f"Not enough memory to load remaining data. "
+                    f"Available: {available_memory_kb}KB, estimated need: {int(data_piece_size_kb * 1.1)}KB"
+                )
+
+    def _iterate_with_memory_check(self) -> Generator[pandas.DataFrame, None, None]:
+        """Iterate over `_data_generator` with memory safety checks.
+
+        Yields:
+            pandas.DataFrame: The next chunk from the underlying data generator.
+
+        Raises:
+            MemoryError: Propagated from `_raise_if_low_memory` if available
+                         memory is insufficient for the next chunk.
+        """
+        if self._data_generator is None:
+            return
+
+        self._raise_if_low_memory()
+
+        for piece in self._data_generator:
+            self._last_data_piece = piece
+            self.rows_fetched += len(piece)
+            yield piece
+            self._raise_if_low_memory()
+
+    def fetchmany(self) -> pandas.DataFrame | None:
+        """Fetch one piece of data and store it in the _data attribute.
+
+        Returns:
+            pandas.DataFrame: Data frame, piece of data.
+        """
+        self._raise_if_invalid()
+        try:
+            piece = next(self._iterate_with_memory_check())
+            if self._data is None:
+                self._data = piece
+            else:
+                self._data = _safe_pandas_concat([self._data, piece])
+        except StopIteration:
+            self._fetched = True
+            self._data_generator = None
+            return None
+        return piece
+
+    def iterate_no_save(self) -> Generator[pandas.DataFrame, None, None]:
+        """Iterate over the data and yield each piece of data. Do not save the data to the _data attribute.
+        NOTE: do it only once, before return result to the user
+
+        Returns:
+            Generator[pandas.DataFrame, None, None]: Generator of data frames.
+        """
+        self._raise_if_invalid()
+        if self._data is not None:
+            yield self._data
+        if self._data_generator:
+            self._invalid = True
+            for piece in self._iterate_with_memory_check():
+                yield piece
+
+    def _raise_if_invalid(self):
+        if self._invalid:
+            raise ValueError("Data has already been fetched and cannot be iterated over.")
+
+    @property
+    def data_frame(self) -> pandas.DataFrame:
+        """Get the data frame. Represents the entire dataset.
+
+        Returns:
+            pandas.DataFrame: Data frame.
+        """
+        self.fetchall()
+        return self._data
+
+    @data_frame.setter
+    def data_frame(self, value):
+        """for back compatibility"""
+        self._data = value
+
+    @property
+    def columns(self) -> list[Column]:
+        """Get the columns.
+
+        Returns:
+            list[Column]: List of columns.
+        """
+        self._resolve_columns()
+        return self._columns
+
+    def _resolve_columns(self):
+        if self._columns is not None:
+            return
+        self.fetchall()
+        self._columns = [Column(name=c) for c in self._data.columns]
+
+    def set_columns_attrs(self, table_name: str | None, table_alias: str | None, database: str | None):
+        """Set the attributes of the columns.
+
+        Args:
+            table_name (str | None): Table name.
+            table_alias (str | None): Table alias.
+            database (str | None): Database name.
+        """
+        self._resolve_columns()
+        for column in self._columns:
+            if table_name:
+                column.table_name = table_name
+            if table_alias:
+                column.table_alias = table_alias
+            if database:
+                column.database = database
+
+    def to_columns_table_response(self, map_type_fn: Callable) -> None:
+        """Transform the response to a `columns table` response.
+        NOTE: original dataframe will be mutated
+
+        Args:
+            map_type_fn (Callable): Function to map the data type to the MySQL data type.
+        """
+        if self.type == RESPONSE_TYPE.COLUMNS_TABLE:
+            return
+        if self.type != RESPONSE_TYPE.TABLE:
+            raise ValueError(
+                f"Cannot convert handler response with type '{self.type}' to '{RESPONSE_TYPE.COLUMNS_TABLE}'"
+            )
+
+        self.fetchall()
+        self._resolve_columns()
+        self.type = RESPONSE_TYPE.COLUMNS_TABLE
+
+        if self._data is None:
+            return
+        self._data.columns = [name.upper() for name in self._data.columns]
+
+        for required_column in (INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME, INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE):
+            if required_column not in self._data.columns:
+                raise ValueError(
+                    f"Missed required for INFORMATION_SCHEMA.COLUMNS column {required_column}. "
+                    f"Columns set: {self._data.columns}"
+                )
+        for column_name in INF_SCHEMA_COLUMNS_NAMES_SET:
+            if column_name not in self._data.columns:
+                self._data[column_name] = None
+
+        self._data[INF_SCHEMA_COLUMNS_NAMES.MYSQL_DATA_TYPE] = self._data[INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE].apply(
+            map_type_fn
+        )
+
+        self._data = self._data.astype(
+            {
+                INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME: "string",
+                INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE: "string",
+                INF_SCHEMA_COLUMNS_NAMES.ORDINAL_POSITION: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.COLUMN_DEFAULT: "string",
+                INF_SCHEMA_COLUMNS_NAMES.IS_NULLABLE: "string",
+                INF_SCHEMA_COLUMNS_NAMES.CHARACTER_MAXIMUM_LENGTH: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.CHARACTER_OCTET_LENGTH: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.NUMERIC_PRECISION: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.NUMERIC_SCALE: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.DATETIME_PRECISION: "Int32",
+                INF_SCHEMA_COLUMNS_NAMES.CHARACTER_SET_NAME: "string",
+                INF_SCHEMA_COLUMNS_NAMES.COLLATION_NAME: "string",
+            }
+        )
+        self._data.replace([numpy.nan, pandas.NA], None, inplace=True)
+
+
+def normalize_response(response) -> TableResponse | OkResponse | ErrorResponse:
+    """Convert legacy HandlerResponse to new response types.
+
+    If response is already a new type (TableResponse, OkResponse, ErrorResponse),
+    return it as-is. If response is a legacy HandlerResponse, convert it based
+    on its resp_type.
+
+    Args:
+        response: Either a new response type or legacy HandlerResponse
+
+    Returns:
+        TableResponse | OkResponse | ErrorResponse: Normalized response
+    """
+    # Already new format - return as-is
+    if isinstance(response, (TableResponse, OkResponse, ErrorResponse)):
+        return response
+
+    # Legacy HandlerResponse - convert based on type
+    if isinstance(response, HandlerResponse):
+        if response.resp_type == RESPONSE_TYPE.ERROR:
+            err = ErrorResponse(
+                error_code=response.error_code,
+                error_message=response.error_message,
+                is_expected_error=response.is_expected_error,
+            )
+            err.exception = response.exception
+            return err
+
+        if response.resp_type == RESPONSE_TYPE.OK:
+            return OkResponse(affected_rows=response.affected_rows)
+
+        # TABLE or COLUMNS_TABLE
+        if response.data_frame is not None:
+            columns = list(response.data_frame.columns)
+        else:
+            columns = []
+
+        mysql_types = response.mysql_types
+        if mysql_types is None:
+            mysql_types = [None] * len(columns)
+
+        table_response = TableResponse(
+            data=response.data_frame,
+            columns=[
+                Column(name=column_name, type=mysql_type) for column_name, mysql_type in zip(columns, mysql_types)
+            ],
+            data_generator=iter([]),  # empty generator for legacy responses
+        )
+        if response.resp_type == RESPONSE_TYPE.COLUMNS_TABLE:
+            table_response.type = RESPONSE_TYPE.COLUMNS_TABLE
+        return table_response
+
+    # Unknown type - return as-is (shouldn't happen normally)
+    return response
+
+
+# ! deprecated
 class HandlerResponse:
+    """Legacy response class for compatibility with old code.
+    NOTE: do not use this class directly, use DataHandlerResponse instead
+    """
+
     def __init__(
         self,
         resp_type: RESPONSE_TYPE,
@@ -86,16 +546,21 @@ def to_columns_table_response(self, map_type_fn: Callable) -> None:
             raise ValueError(f"Cannot convert {self.resp_type} to {RESPONSE_TYPE.COLUMNS_TABLE}")
 
         self.data_frame.columns = [name.upper() for name in self.data_frame.columns]
+
+        for required_column in (INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME, INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE):
+            if required_column not in self.data_frame.columns:
+                raise ValueError(
+                    f"Missed required for INFORMATION_SCHEMA.COLUMNS column {required_column}. "
+                    f"Columns set: {self.data_frame.columns}"
+                )
+        for column_name in INF_SCHEMA_COLUMNS_NAMES_SET:
+            if column_name not in self.data_frame.columns:
+                self.data_frame[column_name] = None
+
         self.data_frame[INF_SCHEMA_COLUMNS_NAMES.MYSQL_DATA_TYPE] = self.data_frame[
             INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE
         ].apply(map_type_fn)
 
-        # region validate df
-        current_columns_set = set(self.data_frame.columns)
-        if INF_SCHEMA_COLUMNS_NAMES_SET != current_columns_set:
-            raise ValueError(f"Columns set for INFORMATION_SCHEMA.COLUMNS is wrong: {list(current_columns_set)}")
-        # endregion
-
         self.data_frame = self.data_frame.astype(
             {
                 INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME: "string",
@@ -142,28 +607,3 @@ def __repr__(self):
             self.error_message,
             self.affected_rows,
         )
-
-
-class HandlerStatusResponse:
-    def __init__(
-        self,
-        success: bool = True,
-        error_message: str = None,
-        redirect_url: str = None,
-        copy_storage: str = None,
-    ) -> None:
-        self.success = success
-        self.error_message = error_message
-        self.redirect_url = redirect_url
-        self.copy_storage = copy_storage
-
-    def to_json(self):
-        data = {"success": self.success, "error": self.error_message}
-        if self.redirect_url is not None:
-            data["redirect_url"] = self.redirect_url
-        return data
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}: success={self.success},\
-              error={self.error_message},\
-              redirect_url={self.redirect_url}"
diff --git a/mindsdb/integrations/libs/vectordatabase_handler.py b/mindsdb/integrations/libs/vectordatabase_handler.py
index 4f332e53028..1c8b9074b2c 100644
--- a/mindsdb/integrations/libs/vectordatabase_handler.py
+++ b/mindsdb/integrations/libs/vectordatabase_handler.py
@@ -2,7 +2,7 @@
 import copy
 import hashlib
 from enum import Enum
-from typing import Dict, List, Optional
+from typing import List, Optional
 import datetime as dt
 
 import pandas as pd
@@ -22,11 +22,10 @@
 )
 from mindsdb_sql_parser.ast.base import ASTNode
 
-from mindsdb.integrations.libs.response import RESPONSE_TYPE, HandlerResponse
-from mindsdb.utilities import log
+from mindsdb.integrations.libs.response import DataHandlerResponse, OkResponse, TableResponse
 from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator, KeywordSearchArgs
-
 from mindsdb.integrations.utilities.query_traversal import query_traversal
+from mindsdb.utilities import log
 from .base import BaseHandler
 
 LOG = log.getLogger(__name__)
@@ -521,7 +520,7 @@ def dispatch_select(
                 handler_engine = self.__class__.name
                 raise VectorHandlerException(f"Error in {handler_engine} database: {e}")
 
-    def _dispatch(self, query: ASTNode) -> HandlerResponse:
+    def _dispatch(self, query: ASTNode) -> DataHandlerResponse:
         """
         Parse and Dispatch query to the appropriate method.
         """
@@ -536,14 +535,14 @@ def _dispatch(self, query: ASTNode) -> HandlerResponse:
         if type(query) in dispatch_router:
             resp = dispatch_router[type(query)](query)
             if resp is not None:
-                return HandlerResponse(resp_type=RESPONSE_TYPE.TABLE, data_frame=resp)
+                return TableResponse(data=resp)
             else:
-                return HandlerResponse(resp_type=RESPONSE_TYPE.OK)
+                return OkResponse()
 
         else:
             raise NotImplementedError(f"Query type {type(query)} not implemented.")
 
-    def query(self, query: ASTNode) -> HandlerResponse:
+    def query(self, query: ASTNode) -> DataHandlerResponse:
         """
         Receive query as AST (abstract syntax tree) and act upon it somehow.
 
@@ -552,11 +551,11 @@ def query(self, query: ASTNode) -> HandlerResponse:
                 of query: SELECT, INSERT, DELETE, etc
 
         Returns:
-            HandlerResponse
+            DataHandlerResponse
         """
         return self._dispatch(query)
 
-    def create_table(self, table_name: str, if_not_exists=True) -> HandlerResponse:
+    def create_table(self, table_name: str, if_not_exists=True) -> DataHandlerResponse:
         """Create table
 
         Args:
@@ -564,11 +563,11 @@ def create_table(self, table_name: str, if_not_exists=True) -> HandlerResponse:
             if_not_exists (bool): if True, do nothing if table exists
 
         Returns:
-            HandlerResponse
+            DataHandlerResponse
         """
         raise NotImplementedError()
 
-    def drop_table(self, table_name: str, if_exists=True) -> HandlerResponse:
+    def drop_table(self, table_name: str, if_exists=True) -> DataHandlerResponse:
         """Drop table
 
         Args:
@@ -576,11 +575,11 @@ def drop_table(self, table_name: str, if_exists=True) -> HandlerResponse:
             if_exists (bool): if True, do nothing if table does not exist
 
         Returns:
-            HandlerResponse
+            DataHandlerResponse
         """
         raise NotImplementedError()
 
-    def insert(self, table_name: str, data: pd.DataFrame) -> HandlerResponse:
+    def insert(self, table_name: str, data: pd.DataFrame) -> DataHandlerResponse:
         """Insert data into table
 
         Args:
@@ -589,11 +588,11 @@ def insert(self, table_name: str, data: pd.DataFrame) -> HandlerResponse:
             columns (List[str]): columns to insert
 
         Returns:
-            HandlerResponse
+            DataHandlerResponse
         """
         raise NotImplementedError()
 
-    def delete(self, table_name: str, conditions: List[FilterCondition] = None) -> HandlerResponse:
+    def delete(self, table_name: str, conditions: List[FilterCondition] = None) -> DataHandlerResponse:
         """Delete data from table
 
         Args:
@@ -601,7 +600,7 @@ def delete(self, table_name: str, conditions: List[FilterCondition] = None) -> H
             conditions (List[FilterCondition]): conditions to delete
 
         Returns:
-            HandlerResponse
+            DataHandlerResponse
         """
         raise NotImplementedError()
 
@@ -612,7 +611,7 @@ def select(
         conditions: List[FilterCondition] = None,
         offset: int = None,
         limit: int = None,
-    ) -> pd.DataFrame:
+    ) -> DataHandlerResponse:
         """Select data from table
 
         Args:
@@ -621,44 +620,15 @@ def select(
             conditions (List[FilterCondition]): conditions to select
 
         Returns:
-            HandlerResponse
+            DataHandlerResponse
         """
         raise NotImplementedError()
 
-    def get_columns(self, table_name: str) -> HandlerResponse:
+    def get_columns(self, table_name: str) -> TableResponse:
         # return a fixed set of columns
         data = pd.DataFrame(self.SCHEMA)
         data.columns = ["COLUMN_NAME", "DATA_TYPE"]
-        return HandlerResponse(
-            resp_type=RESPONSE_TYPE.TABLE,
-            data_frame=data,
-        )
-
-    def hybrid_search(
-        self,
-        table_name: str,
-        embeddings: List[float],
-        query: str = None,
-        metadata: Dict[str, str] = None,
-        distance_function=DistanceFunction.COSINE_DISTANCE,
-        **kwargs,
-    ) -> pd.DataFrame:
-        """
-        Executes a hybrid search, combining semantic search and one or both of keyword/metadata search.
-
-        For insight on the query construction, see: https://docs.pgvecto.rs/use-case/hybrid-search.html#advanced-search-merge-the-results-of-full-text-search-and-vector-search.
-
-        Args:
-            table_name(str): Name of underlying table containing content, embeddings, & metadata
-            embeddings(List[float]): Embedding vector to perform semantic search against
-            query(str): User query to convert into keywords for keyword search
-            metadata(Dict[str, str]): Metadata filters to filter content rows against
-            distance_function(DistanceFunction): Distance function used to compare embeddings vectors for semantic search
-
-        Returns:
-            df(pd.DataFrame): Hybrid search result, sorted by hybrid search rank
-        """
-        raise NotImplementedError(f"Hybrid search not supported for VectorStoreHandler {self.name}")
+        return TableResponse(data=data)
 
     def check_existing_ids(self, table_name: str, ids: List[str]) -> List[str]:
         """
diff --git a/mindsdb/integrations/utilities/files/file_reader.py b/mindsdb/integrations/utilities/files/file_reader.py
index 460ddd5137e..ab88dbfc486 100644
--- a/mindsdb/integrations/utilities/files/file_reader.py
+++ b/mindsdb/integrations/utilities/files/file_reader.py
@@ -37,6 +37,7 @@ class _SINGLE_PAGE_FORMAT:
 @dataclass(frozen=True, slots=True)
 class _MULTI_PAGE_FORMAT:
     XLSX: str = "xlsx"
+    XLS: str = "xls"
 
 
 MULTI_PAGE_FORMAT = _MULTI_PAGE_FORMAT()
@@ -120,6 +121,10 @@ def __init__(
 
         self.parameters = {}
 
+    def close(self):
+        if self.file_obj is not None:
+            self.file_obj.close()
+
     def get_format(self) -> str:
         if self.format is not None:
             return self.format
@@ -155,9 +160,10 @@ def get_format_by_content(self):
         if file_type is not None:
             if file_type.mime in {
                 "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                "application/vnd.ms-excel",
             }:
                 return MULTI_PAGE_FORMAT.XLSX
+            if file_type.mime == "application/vnd.ms-excel":
+                return MULTI_PAGE_FORMAT.XLS
 
             if file_type.mime == "application/pdf":
                 return SINGLE_PAGE_FORMAT.PDF
@@ -381,3 +387,12 @@ def read_xlsx(
                 else:
                     df = pd.read_excel(xls, sheet_name=page_name)
                 yield page_name, df
+
+    @staticmethod
+    def read_xls(
+        file_obj: BytesIO,
+        page_name: str | None = None,
+        only_names: bool = False,
+        **kwargs,
+    ):
+        return FileReader.read_xlsx(file_obj, page_name=page_name, only_names=only_names, **kwargs)
diff --git a/mindsdb/integrations/utilities/install.py b/mindsdb/integrations/utilities/install.py
index 388edc9703d..9a56b2e4ae4 100644
--- a/mindsdb/integrations/utilities/install.py
+++ b/mindsdb/integrations/utilities/install.py
@@ -1,66 +1,77 @@
 import os
 import sys
 import subprocess
+from enum import Enum
 from typing import Text, List
 
 
-def install_dependencies(dependencies: List[Text]) -> dict:
+class InstallTool(Enum):
+    pip = (sys.executable, "-m", "pip")
+    uv = ("uv", "pip")
+
+
+def install_dependencies(dependencies: List[Text], tool: InstallTool = InstallTool.pip) -> dict:
     """
     Installs the dependencies for a handler by calling the `pip install` command via subprocess.
 
     Args:
         dependencies (List[Text]): List of dependencies for the handler.
+        tool (InstallTool): tool the tool that will be used to install dependencies
 
     Returns:
         dict: A dictionary containing the success status and an error message if an error occurs.
     """
-    outs = b''
-    errs = b''
-    result = {
-        'success': False,
-        'error_message': None
-    }
+    outs = b""
+    errs = b""
+    result = {"success": False, "error_message": None}
     code = None
 
     try:
         # Split the dependencies by parsing the contents of the requirements.txt file.
         split_dependencies = parse_dependencies(dependencies)
     except FileNotFoundError as file_not_found_error:
-        result['error_message'] = f"Error parsing dependencies, file not found: {str(file_not_found_error)}"
+        result["error_message"] = f"Error parsing dependencies, file not found: {str(file_not_found_error)}"
         return result
     except Exception as unknown_error:
-        result['error_message'] = f"Unknown error parsing dependencies: {str(unknown_error)}"
+        result["error_message"] = f"Unknown error parsing dependencies: {str(unknown_error)}"
         return result
 
     try:
-        # Install the dependencies using the `pip install` command.
+        # Install the dependencies using the selected tool.
         sp = subprocess.Popen(
-            [sys.executable, '-m', 'pip', 'install', *split_dependencies],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
+            [*tool.value, "install", *split_dependencies], stdout=subprocess.PIPE, stderr=subprocess.PIPE
         )
         code = sp.wait()
         outs, errs = sp.communicate(timeout=1)
     except subprocess.TimeoutExpired as timeout_error:
         sp.kill()
-        result['error_message'] = f"Timeout error while installing dependencies: {str(timeout_error)}"
+        result["error_message"] = f"Timeout error while installing dependencies: {str(timeout_error)}"
+        return result
+    except FileNotFoundError as e:
+        if e.filename == "uv":
+            result["error_message"] = "The 'pip' and 'uv' tools are not found. Please install them."
+        else:
+            result["error_message"] = f"FileNotFoundError error while installing dependencies: {str(e)}"
         return result
     except Exception as unknown_error:
-        result['error_message'] = f"Unknown error while installing dependencies: {str(unknown_error)}"
+        result["error_message"] = f"Unknown error while installing dependencies: {str(unknown_error)}"
         return result
 
     # Return the result of the installation if successful, otherwise return an error message.
     if code != 0:
-        output = ''
+        output = ""
         if isinstance(outs, bytes) and len(outs) > 0:
-            output = output + 'Output: ' + outs.decode()
+            output = output + "Output: " + outs.decode()
         if isinstance(errs, bytes) and len(errs) > 0:
             if len(output) > 0:
-                output = output + '\n'
-            output = output + 'Errors: ' + errs.decode()
-        result['error_message'] = output
+                output = output + "\n"
+            output = output + "Errors: " + errs.decode()
+        if "no module named pip" in output.lower() and tool is InstallTool.pip:
+            # try with uv
+            return install_dependencies(dependencies, InstallTool.uv)
+        result["error_message"] = output
     else:
-        result['success'] = True
+        result["success"] = True
 
     return result
 
@@ -85,19 +96,19 @@ def parse_dependencies(dependencies: List[Text]) -> List[Text]:
     split_dependencies = []
     for dependency in dependencies:
         # ignore standalone comments
-        if dependency.startswith('#'):
+        if dependency.startswith("#"):
             continue
 
         # remove inline comments
-        if '#' in dependency:
-            dependency = dependency.split('#')[0].strip()
+        if "#" in dependency:
+            dependency = dependency.split("#")[0].strip()
 
         # check if the dependency is a path to a requirements file
-        if dependency.startswith('-r'):
+        if dependency.startswith("-r"):
             # get the path to the requirements file
-            req_path = dependency.split(' ')[1]
+            req_path = dependency.split(" ")[1]
             # create the absolute path to the requirements file
-            abs_req_path = os.path.abspath(os.path.join(script_path, req_path.replace('mindsdb/integrations', '..')))
+            abs_req_path = os.path.abspath(os.path.join(script_path, req_path.replace("mindsdb/integrations", "..")))
             # check if the file exists
             if os.path.exists(abs_req_path):
                 inner_dependencies, inner_split_dependencies = [], []
@@ -128,7 +139,7 @@ def read_dependencies(path: Text) -> List[Text]:
     """
     dependencies = []
     # read the dependencies from the file
-    with open(str(path), 'rt') as f:
-        dependencies = [x.strip(' \t\n') for x in f.readlines()]
+    with open(str(path), "rt") as f:
+        dependencies = [x.strip(" \t\n") for x in f.readlines()]
         dependencies = [x for x in dependencies if len(x) > 0]
     return dependencies
diff --git a/mindsdb/integrations/utilities/rag/config_loader.py b/mindsdb/integrations/utilities/rag/config_loader.py
deleted file mode 100644
index 51732358ca6..00000000000
--- a/mindsdb/integrations/utilities/rag/config_loader.py
+++ /dev/null
@@ -1,84 +0,0 @@
-"""Utility functions for RAG pipeline configuration"""
-
-from typing import Dict, Any, Optional
-
-from mindsdb.utilities.log import getLogger
-from mindsdb.integrations.utilities.rag.settings import (
-    RetrieverType,
-    MultiVectorRetrieverMode,
-    SearchType,
-    SearchKwargs,
-    VectorStoreConfig,
-    RerankerConfig,
-    RAGPipelineModel,
-    DEFAULT_COLLECTION_NAME,
-)
-
-logger = getLogger(__name__)
-
-
-def load_rag_config(
-    base_config: Dict[str, Any], kb_params: Optional[Dict[str, Any]] = None, embedding_model: Any = None
-) -> RAGPipelineModel:
-    """
-    Load and validate RAG configuration parameters. This function handles the conversion of configuration
-    parameters into their appropriate types and ensures all required settings are properly configured.
-
-    Args:
-        base_config: Base configuration dictionary containing RAG pipeline settings
-        kb_params: Optional knowledge base parameters to merge with base config
-        embedding_model: Optional embedding model instance to use in the RAG pipeline
-
-    Returns:
-        RAGPipelineModel: Validated RAG configuration model ready for pipeline creation
-
-    Raises:
-        ValueError: If configuration validation fails or required parameters are missing
-    """
-    # Create a shallow copy of the base config to avoid modifying the original
-    # We avoid deepcopy because some objects (like embedding_model) may contain unpickleable objects
-    rag_params = base_config.copy()
-
-    # Merge with knowledge base params if provided
-    if kb_params:
-        rag_params.update(kb_params)
-
-    # Set embedding model if provided
-    if embedding_model is not None:
-        rag_params["embedding_model"] = embedding_model
-
-    # Handle enums and type conversions
-    if "retriever_type" in rag_params:
-        rag_params["retriever_type"] = RetrieverType(rag_params["retriever_type"])
-    if "multi_retriever_mode" in rag_params:
-        rag_params["multi_retriever_mode"] = MultiVectorRetrieverMode(rag_params["multi_retriever_mode"])
-    if "search_type" in rag_params:
-        rag_params["search_type"] = SearchType(rag_params["search_type"])
-
-    # Handle search kwargs if present
-    if "search_kwargs" in rag_params and isinstance(rag_params["search_kwargs"], dict):
-        rag_params["search_kwargs"] = SearchKwargs(**rag_params["search_kwargs"])
-
-    # Summarization config removed - no longer supported
-
-    # Handle vector store config
-    if "vector_store_config" in rag_params:
-        if isinstance(rag_params["vector_store_config"], dict):
-            rag_params["vector_store_config"] = VectorStoreConfig(**rag_params["vector_store_config"])
-    else:
-        rag_params["vector_store_config"] = {}
-        logger.warning(
-            f"No collection_name specified for the retrieval tool, "
-            f"using default collection_name: '{DEFAULT_COLLECTION_NAME}'"
-            f"\nWarning: If this collection does not exist, no data will be retrieved"
-        )
-
-    if "reranker_config" in rag_params:
-        rag_params["reranker_config"] = RerankerConfig(**rag_params["reranker_config"])
-
-    # Convert to RAGPipelineModel with validation
-    try:
-        return RAGPipelineModel(**rag_params)
-    except Exception as e:
-        logger.exception("Invalid RAG configuration:")
-        raise ValueError(f"Configuration validation failed: {str(e)}") from e
diff --git a/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/MDBVectorStore.py b/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/MDBVectorStore.py
deleted file mode 100644
index 8e5575af0bd..00000000000
--- a/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/MDBVectorStore.py
+++ /dev/null
@@ -1,46 +0,0 @@
-from mindsdb_sql_parser.ast import Select, BinaryOperation, Identifier, Constant, Star
-from mindsdb.integrations.libs.vectordatabase_handler import TableField
-
-from typing import Any, List, Optional
-
-from mindsdb.integrations.utilities.rag.loaders.vector_store_loader.base_vector_store import VectorStore
-from mindsdb.interfaces.knowledge_base.preprocessing.document_types import SimpleDocument
-
-
-class MDBVectorStore(VectorStore):
-    def __init__(self, kb_table) -> None:
-        self.kb_table = kb_table
-
-    @property
-    def embeddings(self) -> Optional[Any]:
-        return None
-
-    def similarity_search(
-        self,
-        query: str,
-        k: int = 4,
-        **kwargs: Any,
-    ) -> List[SimpleDocument]:
-        query = Select(
-            targets=[Star()],
-            where=BinaryOperation(op="=", args=[Identifier(TableField.CONTENT.value), Constant(query)]),
-            limit=Constant(k),
-        )
-
-        df = self.kb_table.select_query(query)
-
-        docs = []
-        for _, row in df.iterrows():
-            metadata = row[TableField.METADATA.value]
-            if metadata is None:
-                metadata = {}
-            docs.append(SimpleDocument(page_content=row[TableField.CONTENT.value], metadata=metadata))
-
-        return docs
-
-    def add_texts(self, *args, **kwargs) -> List[str]:
-        raise NotImplementedError
-
-    @classmethod
-    def from_texts(self, *args, **kwargs):
-        raise NotImplementedError
diff --git a/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/base_vector_store.py b/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/base_vector_store.py
deleted file mode 100644
index f8e12a70e8a..00000000000
--- a/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/base_vector_store.py
+++ /dev/null
@@ -1,111 +0,0 @@
-"""Base VectorStore interface to replace langchain VectorStore"""
-
-from typing import Any, List, Optional, Tuple
-from abc import ABC, abstractmethod
-
-
-class VectorStore(ABC):
-    """Base class for vector stores to replace langchain VectorStore"""
-
-    @property
-    @abstractmethod
-    def embeddings(self) -> Optional[Any]:
-        """Return embeddings model if available"""
-        pass
-
-    @abstractmethod
-    def similarity_search(
-        self,
-        query: str,
-        k: int = 4,
-        **kwargs: Any,
-    ) -> List[Any]:
-        """Return most similar documents to query"""
-        pass
-
-    def similarity_search_with_score(
-        self,
-        query: str,
-        k: int = 4,
-        **kwargs: Any,
-    ) -> List[Tuple[Any, float]]:
-        """Return most similar documents with scores"""
-        # Default implementation using similarity_search
-        docs = self.similarity_search(query, k=k, **kwargs)
-        # Return with dummy scores if not overridden
-        return [(doc, 0.0) for doc in docs]
-
-    def as_retriever(self, **kwargs: Any) -> Any:
-        """Return a retriever interface"""
-
-        # Create a simple retriever wrapper
-        class SimpleRetriever:
-            def __init__(self, vector_store):
-                self.vector_store = vector_store
-
-            def get_relevant_documents(self, query: str) -> List[Any]:
-                return self.vector_store.similarity_search(query, **kwargs)
-
-            def invoke(self, query: str) -> List[Any]:
-                return self.get_relevant_documents(query)
-
-        return SimpleRetriever(self)
-
-    def add_texts(self, *args: Any, **kwargs: Any) -> List[str]:
-        """Add texts to the vector store"""
-        raise NotImplementedError("add_texts not implemented")
-
-    def add_documents(self, documents: List[Any], **kwargs: Any) -> List[str]:
-        """
-        Add documents to the vector store.
-        Extracts page_content and metadata from documents and calls add_texts.
-
-        Args:
-            documents: List of document-like objects with page_content and metadata attributes
-            **kwargs: Additional arguments to pass to add_texts
-
-        Returns:
-            List of document IDs (if supported by implementation)
-        """
-        texts = []
-        metadatas = []
-        for doc in documents:
-            # Use duck typing to access page_content and metadata
-            page_content = getattr(doc, "page_content", str(doc))
-            metadata = getattr(doc, "metadata", {})
-            texts.append(page_content)
-            metadatas.append(metadata)
-
-        # Call add_texts with texts and metadatas
-        return self.add_texts(texts, metadatas=metadatas, **kwargs)
-
-    @classmethod
-    def from_texts(cls, *args: Any, **kwargs: Any):
-        """Create vector store from texts"""
-        raise NotImplementedError("from_texts not implemented")
-
-    @classmethod
-    def from_documents(cls, documents: List[Any], embedding: Any, **kwargs: Any):
-        """
-        Create vector store from documents.
-        Extracts texts and metadata from documents and calls from_texts.
-
-        Args:
-            documents: List of document-like objects with page_content and metadata attributes
-            embedding: Embedding model/function
-            **kwargs: Additional arguments to pass to from_texts
-
-        Returns:
-            VectorStore instance
-        """
-        texts = []
-        metadatas = []
-        for doc in documents:
-            # Use duck typing to access page_content and metadata
-            page_content = getattr(doc, "page_content", str(doc))
-            metadata = getattr(doc, "metadata", {})
-            texts.append(page_content)
-            metadatas.append(metadata)
-
-        # Call from_texts with texts, metadatas, and embedding
-        return cls.from_texts(texts, embedding=embedding, metadatas=metadatas, **kwargs)
diff --git a/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/pgvector.py b/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/pgvector.py
deleted file mode 100644
index bba23a53c23..00000000000
--- a/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/pgvector.py
+++ /dev/null
@@ -1,226 +0,0 @@
-from typing import Any, List, Union, Optional, Dict, Tuple
-
-from pgvector.sqlalchemy import SPARSEVEC, Vector
-import sqlalchemy as sa
-from sqlalchemy.dialects.postgresql import JSON
-from sqlalchemy.orm import Session
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-
-from mindsdb.integrations.utilities.rag.loaders.vector_store_loader.base_vector_store import VectorStore
-from mindsdb.interfaces.knowledge_base.preprocessing.document_types import SimpleDocument
-from mindsdb.utilities import log
-
-logger = log.getLogger(__name__)
-
-# SQLAlchemy declarative base
-Base = declarative_base()
-
-_generated_sa_tables = {}
-
-
-class PGVectorMDB(VectorStore):
-    """
-    Custom PGVector implementation for mindsdb vector store table structure
-    Replaces langchain_community.vectorstores.PGVector
-    """
-
-    def __init__(
-        self,
-        connection_string: str,
-        collection_name: str,
-        embedding_function: Any = None,
-        is_sparse: bool = False,
-        vector_size: Optional[int] = None,
-        **kwargs,
-    ):
-        """
-        Initialize PGVectorMDB
-
-        Args:
-            connection_string: PostgreSQL connection string
-            collection_name: Name of the table/collection
-            embedding_function: Embedding function/model
-            is_sparse: Whether to use sparse vectors
-            vector_size: Size of sparse vectors (required if is_sparse=True)
-        """
-        self.is_sparse = is_sparse
-        if is_sparse and vector_size is None:
-            raise ValueError("vector_size is required when is_sparse=True")
-        self.vector_size = vector_size
-        self.collection_name = collection_name
-        self.embedding_function = embedding_function
-
-        # Create SQLAlchemy engine
-        self._bind = create_engine(connection_string, pool_pre_ping=True)
-
-        # Initialize table structure
-        self.__post_init__()
-
-    def __post_init__(
-        self,
-    ) -> None:
-        """Initialize SQLAlchemy table structure"""
-        collection_name = self.collection_name
-
-        if collection_name not in _generated_sa_tables:
-
-            class EmbeddingStore(Base):
-                """Embedding store."""
-
-                __tablename__ = collection_name
-
-                id = sa.Column(sa.Integer, primary_key=True)
-                embedding = sa.Column(
-                    "embeddings",
-                    SPARSEVEC()
-                    if self.is_sparse
-                    else Vector()
-                    if self.vector_size is None
-                    else SPARSEVEC(self.vector_size)
-                    if self.is_sparse
-                    else Vector(self.vector_size),
-                )
-                document = sa.Column("content", sa.String, nullable=True)
-                cmetadata = sa.Column("metadata", JSON, nullable=True)
-
-            _generated_sa_tables[collection_name] = EmbeddingStore
-
-        self.EmbeddingStore = _generated_sa_tables[collection_name]
-
-    @property
-    def embeddings(self) -> Optional[Any]:
-        """Return embedding function if available"""
-        return self.embedding_function
-
-    def similarity_search(
-        self,
-        query: str,
-        k: int = 4,
-        **kwargs: Any,
-    ) -> List[SimpleDocument]:
-        """Return most similar documents to query"""
-        # Get embedding for query
-        if self.embedding_function is None:
-            raise ValueError("embedding_function is required for similarity_search")
-
-        # Embed the query
-        query_embedding = self.embedding_function.embed_query(query)
-
-        # Query collection
-        results = self.__query_collection(query_embedding, k=k, filter=kwargs.get("filter"))
-
-        # Convert to SimpleDocument objects
-        docs = []
-        for result in results:
-            embedding_store = result.EmbeddingStore
-            page_content = embedding_store.document or ""
-            metadata = embedding_store.cmetadata or {}
-            docs.append(SimpleDocument(page_content=page_content, metadata=metadata))
-
-        return docs
-
-    def similarity_search_with_score(
-        self,
-        query: str,
-        k: int = 4,
-        **kwargs: Any,
-    ) -> List[Tuple[SimpleDocument, float]]:
-        """Return most similar documents with scores"""
-        # Get embedding for query
-        if self.embedding_function is None:
-            raise ValueError("embedding_function is required for similarity_search_with_score")
-
-        # Embed the query
-        query_embedding = self.embedding_function.embed_query(query)
-
-        # Query collection
-        results = self.__query_collection(query_embedding, k=k, filter=kwargs.get("filter"))
-
-        # Convert to SimpleDocument objects with scores
-        docs_with_scores = []
-        for result in results:
-            embedding_store = result.EmbeddingStore
-            page_content = embedding_store.document or ""
-            metadata = embedding_store.cmetadata or {}
-            doc = SimpleDocument(page_content=page_content, metadata=metadata)
-            # Distance is already calculated in __query_collection
-            score = float(result.distance) if hasattr(result, "distance") else 0.0
-            docs_with_scores.append((doc, score))
-
-        return docs_with_scores
-
-    def __query_collection(
-        self,
-        embedding: Union[List[float], Dict[int, float], str],
-        k: int = 4,
-        filter: Optional[Dict[str, str]] = None,
-    ) -> List[Any]:
-        """Query the collection."""
-        with Session(self._bind) as session:
-            if self.is_sparse:
-                # Sparse vectors: expect string in format "{key:value,...}/size" or dictionary
-                if isinstance(embedding, dict):
-                    from pgvector.utils import SparseVector
-
-                    embedding = SparseVector(embedding, self.vector_size)
-                    embedding_str = embedding.to_text()
-                elif isinstance(embedding, str):
-                    # Use string as is - it should already be in the correct format
-                    embedding_str = embedding
-                # Use inner product for sparse vectors
-                distance_op = "<#>"
-                # For inner product, larger values are better matches
-                order_direction = "ASC"
-            else:
-                # Dense vectors: expect string in JSON array format or list of floats
-                if isinstance(embedding, list):
-                    embedding_str = f"[{','.join(str(x) for x in embedding)}]"
-                elif isinstance(embedding, str):
-                    embedding_str = embedding
-                # Use cosine similarity for dense vectors
-                distance_op = "<=>"
-                # For cosine similarity, smaller values are better matches
-                order_direction = "ASC"
-
-            # Use SQL directly for vector comparison
-            query = sa.text(
-                f"""
-            SELECT t.*, t.embeddings {distance_op} '{embedding_str}' as distance
-            FROM {self.collection_name} t
-            ORDER BY distance {order_direction}
-            LIMIT {k}
-            """
-            )
-            results = session.execute(query).all()
-
-            # Convert results to the expected format
-            formatted_results = []
-            for rec in results:
-                metadata = rec.metadata if bool(rec.metadata) else {0: 0}
-                embedding_store = self.EmbeddingStore()
-                embedding_store.document = rec.content
-                embedding_store.cmetadata = metadata
-                result = type("Result", (), {"EmbeddingStore": embedding_store, "distance": rec.distance})
-                formatted_results.append(result)
-
-            return formatted_results
-
-    # Aliases for compatibility
-    def _PGVector__query_collection(self, *args, **kwargs):
-        return self.__query_collection(*args, **kwargs)
-
-    def _query_collection(self, *args, **kwargs):
-        return self.__query_collection(*args, **kwargs)
-
-    def create_collection(self):
-        raise RuntimeError("Forbidden")
-
-    def delete_collection(self):
-        raise RuntimeError("Forbidden")
-
-    def delete(self, *args, **kwargs):
-        raise RuntimeError("Forbidden")
-
-    def add_embeddings(self, *args, **kwargs):
-        raise RuntimeError("Forbidden")
diff --git a/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/vector_store_loader.py b/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/vector_store_loader.py
deleted file mode 100644
index a094f5e830e..00000000000
--- a/mindsdb/integrations/utilities/rag/loaders/vector_store_loader/vector_store_loader.py
+++ /dev/null
@@ -1,82 +0,0 @@
-from typing import Any
-
-from pydantic import BaseModel
-
-from mindsdb.integrations.utilities.rag.settings import VectorStoreType, VectorStoreConfig
-from mindsdb.integrations.utilities.rag.loaders.vector_store_loader.base_vector_store import VectorStore
-from mindsdb.integrations.utilities.rag.loaders.vector_store_loader.MDBVectorStore import MDBVectorStore
-from mindsdb.integrations.utilities.rag.loaders.vector_store_loader.pgvector import PGVectorMDB
-from mindsdb.utilities import log
-
-
-logger = log.getLogger(__name__)
-
-
-class VectorStoreLoader(BaseModel):
-    embedding_model: Any  # Embedding model interface
-    vector_store: VectorStore = None
-    config: VectorStoreConfig = None
-
-    class Config:
-        arbitrary_types_allowed = True
-        extra = "forbid"
-        validate_assignment = True
-
-    def load(self) -> VectorStore:
-        """
-        Loads the vector store based on the provided config and embeddings model
-        :return:
-        """
-        if (
-            self.config.is_sparse is not None
-            and self.config.vector_size is not None
-            and self.config.kb_table is not None
-        ):
-            # Only use PGVector store for sparse vectors.
-            db_handler = self.config.kb_table.get_vector_db()
-            db_args = db_handler.connection_args
-            # Assume we are always using PGVector & psycopg2.
-            connection_str = f"postgresql+psycopg2://{db_args.get('user')}:{db_args.get('password')}@{db_args.get('host')}:{db_args.get('port')}/{db_args.get('dbname', db_args.get('database'))}"
-
-            return PGVectorMDB(
-                connection_string=connection_str,
-                collection_name=self.config.kb_table._kb.vector_database_table,
-                embedding_function=self.embedding_model,
-                is_sparse=self.config.is_sparse,
-                vector_size=self.config.vector_size,
-            )
-        return MDBVectorStore(kb_table=self.config.kb_table)
-
-
-class VectorStoreFactory:
-    @staticmethod
-    def create(embedding_model: Any, config: VectorStoreConfig) -> VectorStore:
-        if config.vector_store_type == VectorStoreType.CHROMA:
-            return VectorStoreFactory._load_chromadb_store(embedding_model, config)
-        elif config.vector_store_type == VectorStoreType.PGVECTOR:
-            return VectorStoreFactory._load_pgvector_store(embedding_model, config)
-        else:
-            raise ValueError(f"Invalid vector store type, must be one either {VectorStoreType.__members__.keys()}")
-
-    @staticmethod
-    def _load_chromadb_store(embedding_model: Any, settings) -> VectorStore:
-        # Chroma still uses langchain, import only when needed
-        from langchain_community.vectorstores import Chroma
-
-        return Chroma(
-            persist_directory=settings.persist_directory,
-            collection_name=settings.collection_name,
-            embedding_function=embedding_model,
-        )
-
-    @staticmethod
-    def _load_pgvector_store(embedding_model: Any, settings) -> VectorStore:
-        from .pgvector import PGVectorMDB
-
-        return PGVectorMDB(
-            connection_string=settings.connection_string,
-            collection_name=settings.collection_name,
-            embedding_function=embedding_model,
-            is_sparse=settings.is_sparse,
-            vector_size=settings.vector_size,
-        )
diff --git a/mindsdb/integrations/utilities/rag/pipelines/rag.py b/mindsdb/integrations/utilities/rag/pipelines/rag.py
deleted file mode 100644
index baf8ef8e117..00000000000
--- a/mindsdb/integrations/utilities/rag/pipelines/rag.py
+++ /dev/null
@@ -1,404 +0,0 @@
-from typing import Optional, Any, List, Union
-import asyncio
-
-from mindsdb.interfaces.knowledge_base.embedding_model_utils import construct_embedding_model_from_args
-from mindsdb.integrations.libs.vectordatabase_handler import DistanceFunction
-from mindsdb.integrations.utilities.rag.retrievers.auto_retriever import AutoRetriever
-from mindsdb.integrations.utilities.rag.retrievers.multi_vector_retriever import MultiVectorRetriever
-from mindsdb.integrations.utilities.rag.retrievers.sql_retriever import SQLRetriever
-from mindsdb.integrations.utilities.rag.rerankers.reranker_compressor import LLMReranker
-from mindsdb.integrations.utilities.rag.settings import (
-    RAGPipelineModel,
-    DEFAULT_AUTO_META_PROMPT_TEMPLATE,
-    SearchKwargs,
-    SearchType,
-    RerankerConfig,
-    VectorStoreConfig,
-)
-from mindsdb.integrations.utilities.rag.settings import DEFAULT_RERANKER_FLAG
-
-from mindsdb.integrations.utilities.rag.vector_store import VectorStoreOperator
-from mindsdb.interfaces.knowledge_base.llm_wrapper import create_chat_model
-from mindsdb.interfaces.knowledge_base.preprocessing.document_types import SimpleDocument
-from mindsdb.utilities import log
-
-logger = log.getLogger(__name__)
-
-
-class SimpleRAGPipeline:
-    """
-    Custom RAG pipeline implementation to replace LangChain LCEL components
-    """
-
-    def __init__(
-        self,
-        retriever_runnable: Any,
-        prompt_template: str,
-        llm: Any,
-        reranker: Optional[Any] = None,
-    ):
-        """
-        Initialize SimpleRAGPipeline
-
-        Args:
-            retriever_runnable: Retriever that can be invoked with question
-            prompt_template: Prompt template string with {question} and {context} placeholders
-            llm: Language model with invoke/ainvoke methods
-            reranker: Optional reranker for document reranking
-        """
-        self.retriever_runnable = retriever_runnable
-        self.prompt_template = prompt_template
-        self.llm = llm
-        self.reranker = reranker
-
-    def _format_docs(self, docs: Union[List[Any], str]) -> str:
-        """Format documents into context string"""
-        if isinstance(docs, str):
-            # Handle case where retriever returns a string (e.g., SQLRetriever)
-            return docs
-        if not docs:
-            return ""
-
-        # Sort by original document so we can group source summaries together
-        docs.sort(key=lambda d: d.metadata.get("original_row_id") if hasattr(d, "metadata") and d.metadata else 0)
-        original_document_id = None
-        summary_prepended_text = "Summary of the original document that the below context was taken from:\n"
-        document_content = ""
-
-        for d in docs:
-            metadata = d.metadata if hasattr(d, "metadata") else {}
-            if metadata.get("original_row_id") != original_document_id and metadata.get("summary"):
-                # We have a summary of a new document to prepend
-                original_document_id = metadata.get("original_row_id")
-                summary = f"{summary_prepended_text}{metadata.get('summary')}\n"
-                document_content += summary
-
-            page_content = d.page_content if hasattr(d, "page_content") else str(d)
-            document_content += f"{page_content}\n\n"
-
-        return document_content
-
-    def _format_prompt(self, question: str, context: str) -> str:
-        """Format prompt template with question and context"""
-        return self.prompt_template.format(question=question, context=context)
-
-    def _extract_llm_response(self, response: Any) -> str:
-        """Extract text content from LLM response"""
-        # Handle different response types
-        if isinstance(response, str):
-            return response
-        if hasattr(response, "content"):
-            return response.content
-        if hasattr(response, "text"):
-            return response.text
-        # Try to get from message if it's a message object
-        if hasattr(response, "message") and hasattr(response.message, "content"):
-            return response.message.content
-        # Fallback to string conversion
-        return str(response)
-
-    async def _retrieve_documents(self, question: str) -> List[Any]:
-        """Retrieve documents using retriever"""
-        # Try async first
-        if hasattr(self.retriever_runnable, "ainvoke"):
-            return await self.retriever_runnable.ainvoke(question)
-        elif hasattr(self.retriever_runnable, "invoke"):
-            return self.retriever_runnable.invoke(question)
-        elif hasattr(self.retriever_runnable, "get_relevant_documents"):
-            # Sync method, run in executor for async compatibility
-            loop = asyncio.get_event_loop()
-            return await loop.run_in_executor(None, self.retriever_runnable.get_relevant_documents, question)
-        else:
-            raise ValueError("Retriever must have ainvoke, invoke, or get_relevant_documents method")
-
-    async def ainvoke(self, question: Union[str, dict]) -> dict:
-        """Async invocation of the RAG pipeline"""
-        # Handle both string and dict input (for compatibility)
-        if isinstance(question, dict):
-            question = question.get("question", question.get("input", ""))
-
-        # 1. Retrieve documents
-        docs = await self._retrieve_documents(question)
-
-        # 2. Apply reranker if enabled
-        if self.reranker and docs:
-            try:
-                # Reranker should work with SimpleDocument via duck typing (page_content, metadata attributes)
-                docs = await self.reranker.acompress_documents(docs, question)
-                # Ensure all docs are SimpleDocument instances
-                simple_docs = []
-                for doc in docs:
-                    if isinstance(doc, SimpleDocument):
-                        simple_docs.append(doc)
-                    else:
-                        simple_docs.append(
-                            SimpleDocument(
-                                page_content=doc.page_content if hasattr(doc, "page_content") else str(doc),
-                                metadata=doc.metadata if hasattr(doc, "metadata") else {},
-                            )
-                        )
-                docs = simple_docs
-            except Exception as e:
-                logger.warning(f"Error during reranking, continuing without reranking: {e}")
-
-        # 3. Format documents into context
-        context = self._format_docs(docs)
-
-        # 4. Format prompt
-        formatted_prompt = self._format_prompt(question, context)
-
-        # 5. Generate answer using LLM
-        # Use dict format for messages instead of HumanMessage
-        messages = [{"role": "user", "content": formatted_prompt}]
-
-        # Try different LLM interfaces
-        if hasattr(self.llm, "abatch"):
-            # CustomLLMWrapper interface
-            responses = await self.llm.abatch([formatted_prompt])
-            llm_response = responses[0] if responses else None
-        elif hasattr(self.llm, "ainvoke"):
-            llm_response = await self.llm.ainvoke(messages)
-        elif hasattr(self.llm, "batch"):
-            # CustomLLMWrapper sync interface
-            responses = self.llm.batch([formatted_prompt])
-            llm_response = responses[0] if responses else None
-        elif hasattr(self.llm, "invoke"):
-            loop = asyncio.get_event_loop()
-            llm_response = await loop.run_in_executor(None, self.llm.invoke, messages)
-        else:
-            raise ValueError("LLM must have ainvoke, invoke, abatch, or batch method")
-
-        # 6. Extract text from LLM response
-        answer = self._extract_llm_response(llm_response)
-
-        # 7. Return dict with context, question, answer
-        return {"context": docs, "question": question, "answer": answer}
-
-    def invoke(self, question: Union[str, dict]) -> dict:
-        """Sync invocation of the RAG pipeline"""
-        return asyncio.run(self.ainvoke(question))
-
-
-class LangChainRAGPipeline:
-    """
-    Builds a RAG pipeline using langchain LCEL components
-
-    Args:
-        retriever_runnable: Base retriever component
-        prompt_template: Template for generating responses
-        llm: Language model for generating responses
-        reranker (bool): Whether to use reranking (default: False)
-        reranker_config (RerankerConfig): Configuration for the reranker, including:
-            - model: Model to use for reranking
-            - filtering_threshold: Minimum score to keep a document
-            - num_docs_to_keep: Maximum number of documents to keep
-            - max_concurrent_requests: Maximum concurrent API requests
-            - max_retries: Number of retry attempts for failed requests
-            - retry_delay: Delay between retries
-            - early_stop (bool): Whether to enable early stopping
-            - early_stop_threshold: Confidence threshold for early stopping
-        vector_store_config (VectorStoreConfig): Vector store configuration
-    """
-
-    def __init__(
-        self,
-        retriever_runnable,
-        prompt_template,
-        llm,
-        reranker: bool = DEFAULT_RERANKER_FLAG,
-        reranker_config: Optional[RerankerConfig] = None,
-        vector_store_config: Optional[VectorStoreConfig] = None,
-    ):
-        self.retriever_runnable = retriever_runnable
-        self.prompt_template = prompt_template
-        self.llm = llm
-        if reranker:
-            if reranker_config is None:
-                reranker_config = RerankerConfig()
-            # Convert config to dict and initialize reranker
-            reranker_kwargs = reranker_config.model_dump(exclude_none=True)
-            self.reranker = LLMReranker(**reranker_kwargs)
-        else:
-            self.reranker = None
-        self.vector_store_config = vector_store_config
-
-    def with_returned_sources(self) -> SimpleRAGPipeline:
-        """
-        Builds a RAG pipeline with returned sources
-        :return: SimpleRAGPipeline instance
-        """
-        # Ensure all the required components are not None
-        if self.prompt_template is None:
-            raise ValueError("One of the required components (prompt_template) is None")
-        if self.llm is None:
-            raise ValueError("One of the required components (llm) is None")
-
-        # Return SimpleRAGPipeline instance that handles all the pipeline logic
-        return SimpleRAGPipeline(
-            retriever_runnable=self.retriever_runnable,
-            prompt_template=self.prompt_template,
-            llm=self.llm,
-            reranker=self.reranker,
-        )
-
-    async def ainvoke(self, input_dict: dict) -> dict:
-        """Async invocation of the RAG pipeline."""
-        chain = self.with_returned_sources()
-        return await chain.ainvoke(input_dict)
-
-    def invoke(self, input_dict: dict) -> dict:
-        """Sync invocation of the RAG pipeline."""
-        import asyncio
-
-        return asyncio.run(self.ainvoke(input_dict))
-
-    @classmethod
-    def _apply_search_kwargs(
-        cls, retriever: Any, search_kwargs: Optional[SearchKwargs] = None, search_type: Optional[SearchType] = None
-    ) -> Any:
-        """Apply search kwargs and search type to the retriever if they exist"""
-        if hasattr(retriever, "search_kwargs") and search_kwargs:
-            # Convert search kwargs to dict, excluding None values
-            kwargs_dict = search_kwargs.model_dump(exclude_none=True)
-
-            # Only include relevant parameters based on search type
-            if search_type == SearchType.SIMILARITY:
-                # Remove MMR and similarity threshold specific params
-                kwargs_dict.pop("fetch_k", None)
-                kwargs_dict.pop("lambda_mult", None)
-                kwargs_dict.pop("score_threshold", None)
-            elif search_type == SearchType.MMR:
-                # Remove similarity threshold specific params
-                kwargs_dict.pop("score_threshold", None)
-            elif search_type == SearchType.SIMILARITY_SCORE_THRESHOLD:
-                # Remove MMR specific params
-                kwargs_dict.pop("fetch_k", None)
-                kwargs_dict.pop("lambda_mult", None)
-
-            retriever.search_kwargs.update(kwargs_dict)
-
-            # Set search type if supported by the retriever
-            if hasattr(retriever, "search_type") and search_type:
-                retriever.search_type = search_type.value
-
-        return retriever
-
-    @classmethod
-    def from_retriever(cls, config: RAGPipelineModel):
-        """
-        Builds a RAG pipeline with returned sources using a simple vector store retriever
-        :param config: RAGPipelineModel
-        :return:
-        """
-        vector_store_operator = VectorStoreOperator(
-            vector_store=config.vector_store,
-            documents=config.documents,
-            embedding_model=config.embedding_model,
-            vector_store_config=config.vector_store_config,
-        )
-        retriever = vector_store_operator.vector_store.as_retriever()
-        retriever = cls._apply_search_kwargs(retriever, config.search_kwargs, config.search_type)
-
-        return cls(
-            retriever,
-            config.rag_prompt_template,
-            config.llm,
-            vector_store_config=config.vector_store_config,
-            reranker=config.reranker,
-            reranker_config=config.reranker_config,
-        )
-
-    @classmethod
-    def from_auto_retriever(cls, config: RAGPipelineModel):
-        if not config.retriever_prompt_template:
-            config.retriever_prompt_template = DEFAULT_AUTO_META_PROMPT_TEMPLATE
-
-        retriever = AutoRetriever(config=config).as_runnable()
-        retriever = cls._apply_search_kwargs(retriever, config.search_kwargs, config.search_type)
-        return cls(
-            retriever,
-            config.rag_prompt_template,
-            config.llm,
-            reranker_config=config.reranker_config,
-            reranker=config.reranker,
-            vector_store_config=config.vector_store_config,
-            summarization_config=config.summarization_config,
-        )
-
-    @classmethod
-    def from_multi_vector_retriever(cls, config: RAGPipelineModel):
-        retriever = MultiVectorRetriever(config=config).as_runnable()
-        retriever = cls._apply_search_kwargs(retriever, config.search_kwargs, config.search_type)
-        return cls(
-            retriever,
-            config.rag_prompt_template,
-            config.llm,
-            reranker_config=config.reranker_config,
-            reranker=config.reranker,
-            vector_store_config=config.vector_store_config,
-            summarization_config=config.summarization_config,
-        )
-
-    @classmethod
-    def from_sql_retriever(cls, config: RAGPipelineModel):
-        retriever_config = config.sql_retriever_config
-        if retriever_config is None:
-            raise ValueError('Must provide "sql_retriever_config" for RAG pipeline config')
-        vector_store_config = config.vector_store_config
-        knowledge_base_table = vector_store_config.kb_table if vector_store_config is not None else None
-        if knowledge_base_table is None:
-            raise ValueError('Must provide valid "vector_store_config" for RAG pipeline config')
-        embedding_args = knowledge_base_table._kb.embedding_model.learn_args.get("using", {})
-        embeddings = construct_embedding_model_from_args(embedding_args)
-        sql_llm = create_chat_model(
-            {
-                "model_name": retriever_config.llm_config.model_name,
-                "provider": retriever_config.llm_config.provider,
-                **retriever_config.llm_config.params,
-            }
-        )
-        vector_store_operator = VectorStoreOperator(
-            vector_store=config.vector_store,
-            documents=config.documents,
-            embedding_model=config.embedding_model,
-            vector_store_config=config.vector_store_config,
-        )
-        vector_store_retriever = vector_store_operator.vector_store.as_retriever()
-        vector_store_retriever = cls._apply_search_kwargs(
-            vector_store_retriever, config.search_kwargs, config.search_type
-        )
-        distance_function = DistanceFunction.SQUARED_EUCLIDEAN_DISTANCE
-        if config.vector_store_config.is_sparse and config.vector_store_config.vector_size is not None:
-            # Use negative dot product for sparse retrieval.
-            distance_function = DistanceFunction.NEGATIVE_DOT_PRODUCT
-        retriever = SQLRetriever(
-            fallback_retriever=vector_store_retriever,
-            vector_store_handler=knowledge_base_table.get_vector_db(),
-            min_k=retriever_config.min_k,
-            max_filters=retriever_config.max_filters,
-            filter_threshold=retriever_config.filter_threshold,
-            database_schema=retriever_config.database_schema,
-            embeddings_model=embeddings,
-            search_kwargs=config.search_kwargs,
-            rewrite_prompt_template=retriever_config.rewrite_prompt_template,
-            table_prompt_template=retriever_config.table_prompt_template,
-            column_prompt_template=retriever_config.column_prompt_template,
-            value_prompt_template=retriever_config.value_prompt_template,
-            boolean_system_prompt=retriever_config.boolean_system_prompt,
-            generative_system_prompt=retriever_config.generative_system_prompt,
-            num_retries=retriever_config.num_retries,
-            embeddings_table=knowledge_base_table._kb.vector_database_table,
-            source_table=retriever_config.source_table,
-            source_id_column=retriever_config.source_id_column,
-            distance_function=distance_function,
-            llm=sql_llm,
-        )
-        return cls(
-            retriever,
-            config.rag_prompt_template,
-            config.llm,
-            reranker_config=config.reranker_config,
-            reranker=config.reranker,
-            vector_store_config=config.vector_store_config,
-            summarization_config=config.summarization_config,
-        )
diff --git a/mindsdb/integrations/utilities/rag/rag_pipeline_builder.py b/mindsdb/integrations/utilities/rag/rag_pipeline_builder.py
deleted file mode 100644
index f9709989069..00000000000
--- a/mindsdb/integrations/utilities/rag/rag_pipeline_builder.py
+++ /dev/null
@@ -1,84 +0,0 @@
-import pandas as pd
-from typing import Any
-from mindsdb.integrations.utilities.rag.storage.in_memory_byte_store import InMemoryByteStore
-from mindsdb.integrations.utilities.rag.pipelines.rag import LangChainRAGPipeline
-from mindsdb.integrations.utilities.rag.settings import RetrieverType, RAGPipelineModel
-from mindsdb.integrations.utilities.rag.utils import documents_to_df
-from mindsdb.integrations.utilities.rag.retrievers.multi_hop_retriever import MultiHopRetriever
-from mindsdb.integrations.utilities.rag.splitters.custom_splitters import RecursiveCharacterTextSplitter
-from mindsdb.utilities.log import getLogger
-
-logger = getLogger(__name__)
-
-_retriever_strategies = {
-    RetrieverType.VECTOR_STORE: lambda config: _create_pipeline_from_vector_store(config),
-    RetrieverType.AUTO: lambda config: _create_pipeline_from_auto_retriever(config),
-    RetrieverType.MULTI: lambda config: _create_pipeline_from_multi_retriever(config),
-    RetrieverType.SQL: lambda config: _create_pipeline_from_sql_retriever(config),
-    RetrieverType.MULTI_HOP: lambda config: _create_pipeline_from_multi_hop_retriever(config),
-}
-
-
-def _create_pipeline_from_vector_store(config: RAGPipelineModel) -> LangChainRAGPipeline:
-    return LangChainRAGPipeline.from_retriever(config=config)
-
-
-def _create_pipeline_from_auto_retriever(config: RAGPipelineModel) -> LangChainRAGPipeline:
-    return LangChainRAGPipeline.from_auto_retriever(config=config)
-
-
-def _create_pipeline_from_multi_retriever(config: RAGPipelineModel) -> LangChainRAGPipeline:
-    if config.text_splitter is None:
-        config.text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=config.chunk_size, chunk_overlap=config.chunk_overlap
-        )
-    if config.parent_store is None:
-        config.parent_store = InMemoryByteStore()
-
-    return LangChainRAGPipeline.from_multi_vector_retriever(config=config)
-
-
-def _create_pipeline_from_sql_retriever(config: RAGPipelineModel) -> LangChainRAGPipeline:
-    return LangChainRAGPipeline.from_sql_retriever(config=config)
-
-
-def _create_pipeline_from_multi_hop_retriever(config: RAGPipelineModel) -> LangChainRAGPipeline:
-    retriever = MultiHopRetriever.from_config(config)
-    return LangChainRAGPipeline(
-        retriever_runnable=retriever,
-        prompt_template=config.rag_prompt_template,
-        llm=config.llm,
-        reranker_config=config.reranker_config,
-        reranker=config.reranker,
-        vector_store_config=config.vector_store_config,
-    )
-
-
-def _process_documents_to_df(config: RAGPipelineModel) -> pd.DataFrame:
-    return documents_to_df(
-        config.content_column_name, config.documents, embedding_model=config.embedding_model, with_embeddings=True
-    )
-
-
-def get_pipeline_from_retriever(config: RAGPipelineModel) -> Any:
-    retriever_strategy = _retriever_strategies.get(config.retriever_type)
-    if retriever_strategy:
-        return retriever_strategy(config).with_returned_sources()
-    else:
-        raise ValueError(
-            f"Invalid retriever type, must be one of: {list(_retriever_strategies.keys())}. Got {config.retriever_type}"
-        )
-
-
-class RAG:
-    def __init__(self, config: RAGPipelineModel):
-        self.pipeline = get_pipeline_from_retriever(config)
-
-    def __call__(self, question: str) -> dict:
-        logger.info(f"Processing question using rag pipeline: {question}")
-        result = self.pipeline.invoke(question)
-
-        returned_sources = [docs.page_content for docs in result["context"]]
-        logger.info(f"retrieved context used to answer question: {returned_sources}")
-
-        return result
diff --git a/mindsdb/integrations/utilities/rag/rerankers/base_reranker.py b/mindsdb/integrations/utilities/rag/rerankers/base_reranker.py
index b97b18898fc..c88385f7e2e 100644
--- a/mindsdb/integrations/utilities/rag/rerankers/base_reranker.py
+++ b/mindsdb/integrations/utilities/rag/rerankers/base_reranker.py
@@ -1,13 +1,12 @@
 from __future__ import annotations
 
 import re
+import os
 import json
+import math
 import asyncio
 import logging
-import math
-import os
 import random
-from abc import ABC
 from typing import Any, List, Optional, Tuple
 
 from openai import AsyncOpenAI, AsyncAzureOpenAI
@@ -38,7 +37,7 @@ def get_event_loop():
     return loop
 
 
-class BaseLLMReranker(BaseModel, ABC):
+class BaseLLMReranker(BaseModel):
     filtering_threshold: float = 0.0  # Default threshold for filtering
     provider: str = "openai"
     model: str = DEFAULT_RERANKING_MODEL  # Model to use for reranking
@@ -207,7 +206,7 @@ async def search_relevancy(self, query: str, document: str) -> Any:
             temperature=self.temperature,
             n=1,
             logprobs=True,
-            max_tokens=1,
+            max_completion_tokens=1,
         )
 
         # Extract response and logprobs
@@ -355,7 +354,7 @@ async def search_relevancy_score(self, query: str, document: str) -> Any:
             n=self.n,
             logprobs=self.logprobs,
             top_logprobs=self.top_logprobs,
-            max_tokens=self.max_tokens,
+            max_completion_tokens=self.max_tokens,
         )
 
         # Extract response and logprobs
diff --git a/mindsdb/integrations/utilities/rag/rerankers/reranker_compressor.py b/mindsdb/integrations/utilities/rag/rerankers/reranker_compressor.py
deleted file mode 100644
index 9fdc083ccbf..00000000000
--- a/mindsdb/integrations/utilities/rag/rerankers/reranker_compressor.py
+++ /dev/null
@@ -1,148 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Any, Dict, Optional, Sequence
-
-from mindsdb.integrations.utilities.rag.rerankers.base_reranker import BaseLLMReranker
-
-log = logging.getLogger(__name__)
-
-
-def _dispatch_custom_event(event_name: str, data: dict):
-    """Simple event dispatcher replacement for langchain's dispatch_custom_event.
-
-    This is a no-op implementation. If custom event handling is needed,
-    it can be extended to dispatch events to registered handlers.
-    """
-    # No-op for now - can be extended if needed
-    pass
-
-
-class LLMReranker(BaseLLMReranker):
-    remove_irrelevant: bool = True  # New flag to control removal of irrelevant documents
-
-    def _dispatch_rerank_event(self, data):
-        """Dispatch rerank event using custom event dispatcher"""
-        _dispatch_custom_event("rerank", data)
-
-    async def acompress_documents(
-        self,
-        documents: Sequence[Any],
-        query: str,
-        callbacks: Optional[Any] = None,
-    ) -> Sequence[Any]:
-        """
-        Async compress documents using reranking with proper error handling.
-
-        Args:
-            documents: Sequence of document objects with page_content and metadata attributes
-            query: Query string for reranking
-            callbacks: Optional callbacks object with on_retriever_start, on_retriever_end,
-                     on_text, and on_retriever_error methods
-
-        Returns:
-            Sequence of filtered and reranked documents
-        """
-        if callbacks and hasattr(callbacks, "on_retriever_start"):
-            try:
-                await callbacks.on_retriever_start({"query": query}, "Reranking documents")
-            except Exception as e:
-                log.warning(f"Error in callback on_retriever_start: {e}")
-
-        log.info(f"Async compressing documents. Initial count: {len(documents)}")
-        if not documents:
-            if callbacks and hasattr(callbacks, "on_retriever_end"):
-                try:
-                    await callbacks.on_retriever_end({"documents": []})
-                except Exception as e:
-                    log.warning(f"Error in callback on_retriever_end: {e}")
-            return []
-
-        # Stream reranking update.
-        _dispatch_custom_event("rerank_begin", {"num_documents": len(documents)})
-
-        try:
-            # Prepare query-document pairs
-            # Use duck typing to access page_content attribute
-            query_document_pairs = [(query, doc.page_content) for doc in documents]
-
-            if callbacks and hasattr(callbacks, "on_text"):
-                try:
-                    await callbacks.on_text("Starting document reranking...")
-                except Exception as e:
-                    log.warning(f"Error in callback on_text: {e}")
-
-            # Get ranked results
-            ranked_results = await self._rank(query_document_pairs, rerank_callback=self._dispatch_rerank_event)
-
-            # Sort by score in descending order
-            ranked_results.sort(key=lambda x: x[1], reverse=True)
-
-            # Filter based on threshold and num_docs_to_keep
-            filtered_docs = []
-            for doc, score in ranked_results:
-                if score >= self.filtering_threshold:
-                    matching_doc = next(d for d in documents if d.page_content == doc)
-                    # Use duck typing to access and update metadata
-                    metadata = getattr(matching_doc, "metadata", None) or {}
-                    matching_doc.metadata = {**metadata, "relevance_score": score}
-                    filtered_docs.append(matching_doc)
-
-                    if callbacks and hasattr(callbacks, "on_text"):
-                        try:
-                            await callbacks.on_text(f"Document scored {score:.2f}")
-                        except Exception as e:
-                            log.warning(f"Error in callback on_text: {e}")
-
-                    if self.num_docs_to_keep and len(filtered_docs) >= self.num_docs_to_keep:
-                        break
-
-            log.info(f"Async compression complete. Final count: {len(filtered_docs)}")
-
-            if callbacks and hasattr(callbacks, "on_retriever_end"):
-                try:
-                    await callbacks.on_retriever_end({"documents": filtered_docs})
-                except Exception as e:
-                    log.warning(f"Error in callback on_retriever_end: {e}")
-
-            return filtered_docs
-
-        except Exception as e:
-            error_msg = "Error during async document compression:"
-            log.exception(error_msg)
-            if callbacks and hasattr(callbacks, "on_retriever_error"):
-                try:
-                    await callbacks.on_retriever_error(f"{error_msg} {e}")
-                except Exception as callback_error:
-                    log.warning(f"Error in callback on_retriever_error: {callback_error}")
-            return documents  # Return original documents on error
-
-    def compress_documents(
-        self,
-        documents: Sequence[Any],
-        query: str,
-        callbacks: Optional[Any] = None,
-    ) -> Sequence[Any]:
-        """
-        Sync wrapper for async compression.
-
-        Args:
-            documents: Sequence of document objects with page_content and metadata attributes
-            query: Query string for reranking
-            callbacks: Optional callbacks object
-
-        Returns:
-            Sequence of filtered and reranked documents
-        """
-        return asyncio.run(self.acompress_documents(documents, query, callbacks))
-
-    @property
-    def _identifying_params(self) -> Dict[str, Any]:
-        """Get the identifying parameters."""
-        return {
-            "model": self.model,
-            "temperature": self.temperature,
-            "remove_irrelevant": self.remove_irrelevant,
-            "method": self.method,
-        }
diff --git a/mindsdb/integrations/utilities/rag/retrievers/__init__.py b/mindsdb/integrations/utilities/rag/retrievers/__init__.py
deleted file mode 100644
index 94e359da03a..00000000000
--- a/mindsdb/integrations/utilities/rag/retrievers/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from mindsdb.integrations.utilities.rag.retrievers.multi_hop_retriever import MultiHopRetriever
-
-__all__ = ['MultiHopRetriever']
\ No newline at end of file
diff --git a/mindsdb/integrations/utilities/rag/retrievers/auto_retriever.py b/mindsdb/integrations/utilities/rag/retrievers/auto_retriever.py
deleted file mode 100644
index ba260693c92..00000000000
--- a/mindsdb/integrations/utilities/rag/retrievers/auto_retriever.py
+++ /dev/null
@@ -1,228 +0,0 @@
-from typing import List, Any
-import json
-import asyncio
-
-import pandas as pd
-
-from mindsdb.integrations.utilities.rag.retrievers.base import BaseRetriever, RunnableRetriever
-from mindsdb.integrations.utilities.rag.utils import documents_to_df
-from mindsdb.integrations.utilities.rag.vector_store import VectorStoreOperator
-from mindsdb.integrations.utilities.rag.settings import RAGPipelineModel
-from mindsdb.utilities import log
-
-logger = log.getLogger(__name__)
-
-
-class AutoRetriever(BaseRetriever):
-    """
-    AutoRetrieval is a class that uses LLM to extract metadata from documents and query vectorstore using self-query retrievers.
-    """
-
-    def __init__(self, config: RAGPipelineModel):
-        """
-
-        :param config: RAGPipelineModel
-
-
-        """
-
-        self.documents = config.documents
-        self.content_column_name = config.content_column_name
-        self.vectorstore = config.vector_store
-        self.filter_columns = config.auto_retriever_filter_columns
-        self.document_description = config.dataset_description
-        self.llm = config.llm
-        self.embedding_model = config.embedding_model
-        self.prompt_template = config.retriever_prompt_template
-        self.cardinality_threshold = config.cardinality_threshold
-
-    def _get_low_cardinality_columns(self, data: pd.DataFrame):
-        """
-        Given a dataframe, return a list of columns with low cardinality if datatype is not bool.
-        :return:
-        """
-        low_cardinality_columns = []
-        columns = data.columns if self.filter_columns is None else self.filter_columns
-        for column in columns:
-            if data[column].dtype != "bool":
-                if data[column].nunique() < self.cardinality_threshold:
-                    low_cardinality_columns.append(column)
-        return low_cardinality_columns
-
-    def get_metadata_field_info(self):
-        """
-        Given a list of Document, use llm to extract metadata from it.
-        :return:
-        """
-
-        def _alter_description(data: pd.DataFrame, low_cardinality_columns: list, result: List[dict]):
-            """
-            For low cardinality columns, alter the description to include the sorted valid values.
-            :param data: pd.DataFrame
-            :param low_cardinality_columns: list
-            :param result: List[dict]
-            """
-            for column_name in low_cardinality_columns:
-                valid_values = sorted(data[column_name].unique())
-                for entry in result:
-                    if entry["name"] == column_name:
-                        entry["description"] += f". Valid values: {valid_values}"
-
-        data = documents_to_df(self.content_column_name, self.documents)
-
-        prompt = self.prompt_template.format(dataframe=data.head().to_json(), description=self.document_description)
-        # Call LLM and extract response
-        llm_response = self.llm.invoke(prompt)
-        # Extract content from LLM response
-        if hasattr(llm_response, "content"):
-            response_text = llm_response.content
-        elif isinstance(llm_response, str):
-            response_text = llm_response
-        else:
-            response_text = str(llm_response)
-
-        result: List[dict] = json.loads(response_text)
-
-        _alter_description(data, self._get_low_cardinality_columns(data), result)
-
-        return result
-
-    def get_vectorstore(self):
-        """
-
-        :return:
-        """
-        return VectorStoreOperator(
-            vector_store=self.vectorstore, documents=self.documents, embedding_model=self.embedding_model
-        ).vector_store
-
-    def as_runnable(self) -> RunnableRetriever:
-        """
-        Return a custom self-query retriever
-        :return: CustomSelfQueryRetriever instance
-        """
-        vectorstore = self.get_vectorstore()
-        metadata_field_info = self.get_metadata_field_info()
-
-        return CustomSelfQueryRetriever(
-            llm=self.llm,
-            vectorstore=vectorstore,
-            document_contents=self.document_description,
-            metadata_field_info=metadata_field_info,
-        )
-
-
-class CustomSelfQueryRetriever:
-    """
-    Custom implementation of SelfQueryRetriever to replace langchain's SelfQueryRetriever.
-    Uses LLM to generate metadata filters and queries vectorstore with those filters.
-    """
-
-    def __init__(self, llm: Any, vectorstore: Any, document_contents: str, metadata_field_info: List[dict]):
-        """
-        Initialize CustomSelfQueryRetriever
-
-        Args:
-            llm: LLM instance with invoke method
-            vectorstore: Vector store with similarity_search_with_score method
-            document_contents: Description of document contents
-            metadata_field_info: List of metadata field information dicts
-        """
-        self.llm = llm
-        self.vectorstore = vectorstore
-        self.document_contents = document_contents
-        self.metadata_field_info = metadata_field_info
-
-    def _generate_metadata_filters(self, query: str) -> dict:
-        """
-        Use LLM to generate metadata filters from query
-
-        Args:
-            query: User query string
-
-        Returns:
-            Dictionary of metadata filters
-        """
-        # Create prompt for LLM to generate metadata filters
-        metadata_info_str = json.dumps(self.metadata_field_info, indent=2)
-        prompt = f"""Given the following query and metadata field information, generate a structured query with metadata filters.
-
-Query: {query}
-
-Document contents description: {self.document_contents}
-
-Available metadata fields:
-{metadata_info_str}
-
-Generate a JSON object with the query string and any applicable metadata filters. 
-Format: {{"query": "extracted query", "filters": {{"field_name": "value"}}}}
-"""
-
-        try:
-            llm_response = self.llm.invoke(prompt)
-            # Extract content from LLM response
-            if hasattr(llm_response, "content"):
-                response_text = llm_response.content
-            elif isinstance(llm_response, str):
-                response_text = llm_response
-            else:
-                response_text = str(llm_response)
-
-            # Parse JSON response
-            parsed = json.loads(response_text)
-            return parsed.get("filters", {})
-        except Exception as e:
-            logger.warning(f"Error generating metadata filters: {e}")
-            return {}
-
-    def _query_vectorstore(self, query: str, filters: dict) -> List[Any]:
-        """
-        Query vectorstore with query and metadata filters
-
-        Args:
-            query: Query string
-            filters: Metadata filters dictionary
-
-        Returns:
-            List of documents
-        """
-        # Use vectorstore's similarity_search method
-        # If vectorstore supports metadata filtering, apply filters
-        if hasattr(self.vectorstore, "similarity_search"):
-            # Try to pass filters if supported
-            if filters:
-                try:
-                    # Some vectorstores support filter parameter
-                    if hasattr(self.vectorstore, "similarity_search_with_score"):
-                        docs_with_scores = self.vectorstore.similarity_search_with_score(query, k=4, filter=filters)
-                        return [doc for doc, _ in docs_with_scores]
-                    else:
-                        return self.vectorstore.similarity_search(query, k=4, filter=filters)
-                except TypeError:
-                    # If filter not supported, just do regular search
-                    return self.vectorstore.similarity_search(query, k=4)
-            else:
-                return self.vectorstore.similarity_search(query, k=4)
-        else:
-            raise ValueError("Vectorstore must have similarity_search method")
-
-    def invoke(self, query: str) -> List[Any]:
-        """Sync invocation - retrieve documents for a query"""
-        # Generate metadata filters
-        filters = self._generate_metadata_filters(query)
-
-        # Extract query string (LLM might have rewritten it)
-        # For now, use original query
-        # In a full implementation, we'd extract the rewritten query from LLM response
-
-        # Query vectorstore
-        return self._query_vectorstore(query, filters)
-
-    async def ainvoke(self, query: str) -> List[Any]:
-        """Async invocation - retrieve documents for a query"""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, self.invoke, query)
-
-    def get_relevant_documents(self, query: str) -> List[Any]:
-        """Get relevant documents (sync)"""
-        return self.invoke(query)
diff --git a/mindsdb/integrations/utilities/rag/retrievers/base.py b/mindsdb/integrations/utilities/rag/retrievers/base.py
deleted file mode 100644
index 1c136436aec..00000000000
--- a/mindsdb/integrations/utilities/rag/retrievers/base.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Protocol, List, Any
-
-
-class RunnableRetriever(Protocol):
-    """Protocol for retriever runnable objects that can be invoked to retrieve documents"""
-
-    def invoke(self, query: str) -> List[Any]:
-        """Sync invocation - retrieve documents for a query"""
-        ...
-
-    async def ainvoke(self, query: str) -> List[Any]:
-        """Async invocation - retrieve documents for a query"""
-        ...
-
-    def get_relevant_documents(self, query: str) -> List[Any]:
-        """Get relevant documents (sync) - alternative interface"""
-        ...
-
-
-class BaseRetriever(ABC):
-    """Represents a base retriever for a RAG pipeline"""
-
-    @abstractmethod
-    def as_runnable(self) -> RunnableRetriever:
-        """
-        Return a runnable retriever object that can be invoked.
-
-        Returns:
-            RunnableRetriever: An object that implements invoke(), ainvoke(), or get_relevant_documents()
-        """
-        pass
diff --git a/mindsdb/integrations/utilities/rag/retrievers/multi_hop_retriever.py b/mindsdb/integrations/utilities/rag/retrievers/multi_hop_retriever.py
deleted file mode 100644
index d5bca056e0a..00000000000
--- a/mindsdb/integrations/utilities/rag/retrievers/multi_hop_retriever.py
+++ /dev/null
@@ -1,130 +0,0 @@
-from typing import List, Optional, Any
-
-import json
-from pydantic import Field, PrivateAttr
-
-from mindsdb.integrations.utilities.rag.settings import RAGPipelineModel, DEFAULT_QUESTION_REFORMULATION_TEMPLATE
-from mindsdb.integrations.utilities.rag.retrievers.retriever_factory import create_retriever
-from mindsdb.integrations.utilities.rag.retrievers.base import BaseRetriever, RunnableRetriever
-from mindsdb.utilities import log
-
-logger = log.getLogger(__name__)
-
-
-class MultiHopRetriever(BaseRetriever):
-    """A retriever that implements multi-hop question reformulation strategy.
-
-    This retriever takes a base retriever and uses an LLM to generate follow-up
-    questions based on the initial results. It then retrieves documents for each
-    follow-up question and combines all results.
-    """
-
-    base_retriever: Any = Field(
-        description="Base retriever to use for document lookup (must have get_relevant_documents or invoke method)"
-    )
-    llm: Any = Field(description="LLM to use for generating follow-up questions (must have invoke method)")
-    max_hops: int = Field(default=3, description="Maximum number of follow-up questions to generate")
-    reformulation_template: str = Field(
-        default=DEFAULT_QUESTION_REFORMULATION_TEMPLATE, description="Template for reformulating questions"
-    )
-
-    _asked_questions: set = PrivateAttr(default_factory=set)
-
-    @classmethod
-    def from_config(cls, config: RAGPipelineModel) -> "MultiHopRetriever":
-        """Create a MultiHopRetriever from a RAGPipelineModel config."""
-        if config.multi_hop_config is None:
-            raise ValueError("multi_hop_config must be set for MultiHopRetriever")
-
-        # Create base retriever based on type
-        base_retriever = create_retriever(config, config.multi_hop_config.base_retriever_type)
-
-        return cls(
-            base_retriever=base_retriever,
-            llm=config.llm,
-            max_hops=config.multi_hop_config.max_hops,
-            reformulation_template=config.multi_hop_config.reformulation_template,
-        )
-
-    def _get_relevant_documents(self, query: str, *, run_manager: Optional[Any] = None) -> List[Any]:
-        """
-        Get relevant documents using multi-hop retrieval.
-
-        Args:
-            query: Query string
-            run_manager: Optional callback manager (not used, kept for compatibility)
-
-        Returns:
-            List of documents with page_content and metadata attributes
-        """
-        if query in self._asked_questions:
-            return []
-
-        self._asked_questions.add(query)
-
-        # Get initial documents using duck typing
-        docs = self._retrieve_from_base_retriever(query)
-        if not docs or len(self._asked_questions) >= self.max_hops:
-            return docs
-
-        # Generate follow-up questions
-        context = "\n".join(doc.page_content if hasattr(doc, "page_content") else str(doc) for doc in docs)
-        prompt = self.reformulation_template.format(question=query, context=context)
-
-        try:
-            # Call LLM - handle both string and message formats
-            llm_response = self.llm.invoke(prompt)
-            # Extract content from LLM response
-            if hasattr(llm_response, "content"):
-                response_text = llm_response.content
-            elif isinstance(llm_response, str):
-                response_text = llm_response
-            else:
-                response_text = str(llm_response)
-
-            follow_up_questions = json.loads(response_text)
-            if not isinstance(follow_up_questions, list):
-                return docs
-        except (json.JSONDecodeError, TypeError, Exception) as e:
-            logger.warning(f"Error parsing follow-up questions: {e}")
-            return docs
-
-        # Get documents for follow-up questions
-        for question in follow_up_questions:
-            if isinstance(question, str):
-                follow_up_docs = self._get_relevant_documents(question)
-                docs.extend(follow_up_docs)
-
-        return docs
-
-    def _retrieve_from_base_retriever(self, query: str) -> List[Any]:
-        """Retrieve documents from base retriever using duck typing"""
-        if hasattr(self.base_retriever, "_get_relevant_documents"):
-            return self.base_retriever._get_relevant_documents(query)
-        elif hasattr(self.base_retriever, "get_relevant_documents"):
-            return self.base_retriever.get_relevant_documents(query)
-        elif hasattr(self.base_retriever, "invoke"):
-            return self.base_retriever.invoke(query)
-        else:
-            raise ValueError(
-                "Base retriever must have _get_relevant_documents, get_relevant_documents, or invoke method"
-            )
-
-    def invoke(self, query: str) -> List[Any]:
-        """Sync invocation - retrieve documents for a query"""
-        return self._get_relevant_documents(query)
-
-    async def ainvoke(self, query: str) -> List[Any]:
-        """Async invocation - retrieve documents for a query"""
-        import asyncio
-
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, self._get_relevant_documents, query)
-
-    def get_relevant_documents(self, query: str) -> List[Any]:
-        """Get relevant documents (sync)"""
-        return self._get_relevant_documents(query)
-
-    def as_runnable(self) -> RunnableRetriever:
-        """Return self as a runnable retriever"""
-        return self
diff --git a/mindsdb/integrations/utilities/rag/retrievers/multi_vector_retriever.py b/mindsdb/integrations/utilities/rag/retrievers/multi_vector_retriever.py
deleted file mode 100644
index c7d2c5918bd..00000000000
--- a/mindsdb/integrations/utilities/rag/retrievers/multi_vector_retriever.py
+++ /dev/null
@@ -1,193 +0,0 @@
-from typing import List, Tuple, Any
-import uuid
-import asyncio
-
-from mindsdb.integrations.utilities.rag.retrievers.base import BaseRetriever, RunnableRetriever
-from mindsdb.integrations.utilities.rag.settings import DEFAULT_LLM_MODEL, MultiVectorRetrieverMode, RAGPipelineModel
-from mindsdb.integrations.utilities.rag.vector_store import VectorStoreOperator
-from mindsdb.integrations.utilities.rag.retrievers.safe_output_parser import SafeOutputParser
-from mindsdb.interfaces.knowledge_base.preprocessing.document_types import SimpleDocument
-from mindsdb.utilities import log
-
-logger = log.getLogger(__name__)
-
-
-class MultiVectorRetriever(BaseRetriever):
-    """
-    MultiVectorRetriever stores multiple vectors per document.
-    """
-
-    def __init__(self, config: RAGPipelineModel):
-        self.vectorstore = config.vector_store
-        self.parent_store = config.parent_store
-        self.id_key = config.id_key
-        self.documents = config.documents
-        self.text_splitter = config.text_splitter
-        self.embedding_model = config.embedding_model
-        self.max_concurrency = config.max_concurrency
-        self.mode = config.multi_retriever_mode
-
-    def _generate_id_and_split_document(self, doc: Any) -> Tuple[str, List[Any]]:
-        """
-        Generate a unique id for the document and split it into sub-documents.
-        :param doc: Document with page_content and metadata
-        :return: Tuple of (doc_id, list of sub_documents)
-        """
-        doc_id = str(uuid.uuid4())
-        sub_docs = self.text_splitter.split_documents([doc])
-        for sub_doc in sub_docs:
-            # Use duck typing to access metadata
-            if not hasattr(sub_doc, "metadata"):
-                sub_doc.metadata = {}
-            sub_doc.metadata[self.id_key] = doc_id
-        return doc_id, sub_docs
-
-    def _split_documents(self) -> Tuple[List[Any], List[str]]:
-        """
-        Split the documents into sub-documents and generate unique ids for each document.
-        :return: Tuple of (list of split_docs, list of doc_ids)
-        """
-        split_info = list(map(self._generate_id_and_split_document, self.documents))
-        doc_ids, split_docs_lists = zip(*split_info)
-        split_docs = [doc for sublist in split_docs_lists for doc in sublist]
-        return split_docs, list(doc_ids)
-
-    def _create_retriever_and_vs_operator(
-        self, docs: List[Any]
-    ) -> Tuple["CustomMultiVectorRetriever", VectorStoreOperator]:
-        vstore_operator = VectorStoreOperator(
-            vector_store=self.vectorstore,
-            documents=docs,
-            embedding_model=self.embedding_model,
-        )
-        retriever = CustomMultiVectorRetriever(
-            vectorstore=vstore_operator.vector_store, byte_store=self.parent_store, id_key=self.id_key
-        )
-        return retriever, vstore_operator
-
-    def _get_document_summaries(self, llm: Any) -> List[str]:
-        """
-        Get document summaries using LLM
-
-        Args:
-            llm: LLM instance with invoke method
-
-        Returns:
-            List of summary strings
-        """
-        summaries = []
-        prompt_template = "Summarize the following document:\n\n{doc}"
-
-        for doc in self.documents:
-            # Extract page_content using duck typing
-            page_content = doc.page_content if hasattr(doc, "page_content") else str(doc)
-            prompt = prompt_template.format(doc=page_content)
-
-            try:
-                # Call LLM
-                llm_response = llm.invoke(prompt)
-                # Extract content from LLM response
-                if hasattr(llm_response, "content"):
-                    summary = llm_response.content
-                elif isinstance(llm_response, str):
-                    summary = llm_response
-                else:
-                    summary = str(llm_response)
-
-                # Use SafeOutputParser to clean the output (extract actual text from parse result)
-                parser = SafeOutputParser()
-                parsed_result = parser.parse(summary)
-                summary = parser.extract_output(parsed_result)
-                summaries.append(summary)
-            except Exception as e:
-                logger.warning(f"Error generating summary for document: {e}")
-                # Fallback to empty summary or first part of content
-                summaries.append(page_content[:200] if len(page_content) > 200 else page_content)
-
-        return summaries
-
-    def as_runnable(self) -> RunnableRetriever:
-        # Get LLM from config - need to check how it's passed
-        # For now, assume we need to get it from somewhere
-        # This might need to be passed in config
-        llm = getattr(self, "llm", None)
-        if llm is None:
-            # Try to create a default LLM - this might need adjustment
-            from mindsdb.interfaces.knowledge_base.llm_wrapper import create_chat_model
-
-            llm = create_chat_model({"model_name": DEFAULT_LLM_MODEL, "provider": "openai"})
-
-        if self.mode in {MultiVectorRetrieverMode.SPLIT, MultiVectorRetrieverMode.BOTH}:
-            split_docs, doc_ids = self._split_documents()
-            retriever, vstore_operator = self._create_retriever_and_vs_operator(split_docs)
-            summaries = self._get_document_summaries(llm)
-            summary_docs = [
-                SimpleDocument(page_content=s, metadata={self.id_key: doc_ids[i]}) for i, s in enumerate(summaries)
-            ]
-            vstore_operator.add_documents(summary_docs)
-            retriever.docstore.mset(list(zip(doc_ids, self.documents)))
-            return retriever
-
-        elif self.mode == MultiVectorRetrieverMode.SUMMARIZE:
-            summaries = self._get_document_summaries(llm)
-            doc_ids = [str(uuid.uuid4()) for _ in self.documents]
-            summary_docs = [
-                SimpleDocument(page_content=s, metadata={self.id_key: doc_ids[i]}) for i, s in enumerate(summaries)
-            ]
-            retriever, vstore_operator = self._create_retriever_and_vs_operator(summary_docs)
-            retriever.docstore.mset(list(zip(doc_ids, self.documents)))
-            return retriever
-
-        else:
-            raise ValueError(f"Invalid mode: {self.mode}")
-
-
-class CustomMultiVectorRetriever:
-    """
-    Custom implementation of MultiVectorRetriever to replace langchain's MultiVectorRetriever.
-    Stores parent documents in docstore and sub-documents/summaries in vectorstore.
-    """
-
-    def __init__(self, vectorstore: Any, byte_store: Any, id_key: str = "doc_id"):
-        """
-        Initialize CustomMultiVectorRetriever
-
-        Args:
-            vectorstore: Vector store for storing sub-documents/summaries
-            byte_store: Store for parent documents (must have mset and mget methods)
-            id_key: Key used to link sub-documents to parent documents
-        """
-        self.vectorstore = vectorstore
-        self.docstore = byte_store
-        self.id_key = id_key
-
-    def invoke(self, query: str) -> List[Any]:
-        """Sync invocation - retrieve documents for a query"""
-        # Get sub-documents from vectorstore
-        sub_docs = self.vectorstore.similarity_search(query, k=4)
-
-        # Get parent document IDs from sub-documents
-        parent_ids = []
-        for doc in sub_docs:
-            metadata = getattr(doc, "metadata", {})
-            if self.id_key in metadata:
-                parent_ids.append(metadata[self.id_key])
-
-        # Get parent documents from docstore
-        parent_docs = []
-        if parent_ids and hasattr(self.docstore, "mget"):
-            parent_docs = self.docstore.mget(parent_ids)
-        elif parent_ids and hasattr(self.docstore, "get"):
-            parent_docs = [self.docstore.get(pid) for pid in parent_ids if self.docstore.get(pid) is not None]
-
-        # Return parent documents (or sub-docs if no parent store)
-        return parent_docs if parent_docs else sub_docs
-
-    async def ainvoke(self, query: str) -> List[Any]:
-        """Async invocation - retrieve documents for a query"""
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, self.invoke, query)
-
-    def get_relevant_documents(self, query: str) -> List[Any]:
-        """Get relevant documents (sync)"""
-        return self.invoke(query)
diff --git a/mindsdb/integrations/utilities/rag/retrievers/retriever_factory.py b/mindsdb/integrations/utilities/rag/retrievers/retriever_factory.py
deleted file mode 100644
index 15fec83adcf..00000000000
--- a/mindsdb/integrations/utilities/rag/retrievers/retriever_factory.py
+++ /dev/null
@@ -1,57 +0,0 @@
-"""Factory functions for creating retrievers."""
-
-from mindsdb.integrations.utilities.rag.settings import RAGPipelineModel, RetrieverType
-from mindsdb.integrations.utilities.rag.vector_store import VectorStoreOperator
-from mindsdb.integrations.utilities.rag.retrievers.auto_retriever import AutoRetriever
-from mindsdb.integrations.utilities.rag.retrievers.sql_retriever import SQLRetriever
-
-
-def create_vector_store_retriever(config: RAGPipelineModel):
-    """Create a vector store retriever."""
-    if getattr(config.vector_store, '_mock_return_value', None) is not None:
-        # If vector_store is mocked, return a simple mock retriever for testing
-        from unittest.mock import MagicMock
-        mock_retriever = MagicMock()
-        mock_retriever._get_relevant_documents.return_value = [
-            {"page_content": "The Wright brothers invented the airplane."}
-        ]
-        return mock_retriever
-
-    vector_store_operator = VectorStoreOperator(
-        vector_store=config.vector_store,
-        documents=config.documents,
-        embedding_model=config.embedding_model,
-        vector_store_config=config.vector_store_config
-    )
-    return vector_store_operator.vector_store.as_retriever()
-
-
-def create_auto_retriever(config: RAGPipelineModel):
-    """Create an auto retriever."""
-    return AutoRetriever(
-        vector_store=config.vector_store,
-        documents=config.documents,
-        embedding_model=config.embedding_model
-    )
-
-
-def create_sql_retriever(config: RAGPipelineModel):
-    """Create a SQL retriever."""
-    return SQLRetriever(
-        sql_source=config.sql_source,
-        llm=config.llm
-    )
-
-
-def create_retriever(config: RAGPipelineModel, retriever_type: RetrieverType = None):
-    """Create a retriever based on type."""
-    retriever_type = retriever_type or config.retriever_type
-
-    if retriever_type == RetrieverType.VECTOR_STORE:
-        return create_vector_store_retriever(config)
-    elif retriever_type == RetrieverType.AUTO:
-        return create_auto_retriever(config)
-    elif retriever_type == RetrieverType.SQL:
-        return create_sql_retriever(config)
-    else:
-        raise ValueError(f"Unsupported retriever type: {retriever_type}")
diff --git a/mindsdb/integrations/utilities/rag/retrievers/safe_output_parser.py b/mindsdb/integrations/utilities/rag/retrievers/safe_output_parser.py
deleted file mode 100644
index 0460714eb12..00000000000
--- a/mindsdb/integrations/utilities/rag/retrievers/safe_output_parser.py
+++ /dev/null
@@ -1,92 +0,0 @@
-import re
-from typing import Union
-from dataclasses import dataclass
-
-from mindsdb.utilities import log
-
-logger = log.getLogger(__name__)
-
-# Default format instructions for conversational agent
-# This is a simplified version - can be customized if needed
-FORMAT_INSTRUCTIONS = """Use the following format:
-
-Question: the input question you must answer
-Thought: you should think about what to do
-Action: the action to take, should be one of the available tools
-Action Input: the input to the action
-Observation: the result of the action
-... (this Thought/Action/Action Input/Observation can repeat N times)
-Thought: I now know the final answer
-Final Answer: the final answer to the original input question"""
-
-
-@dataclass
-class AgentAction:
-    """Custom AgentAction class to replace langchain AgentAction"""
-
-    tool: str
-    tool_input: str
-    log: str
-
-
-@dataclass
-class AgentFinish:
-    """Custom AgentFinish class to replace langchain AgentFinish"""
-
-    return_values: dict
-    log: str
-
-
-class SafeOutputParser:
-    """Output parser for the conversational agent that does not throw OutputParserException."""
-
-    def __init__(self, ai_prefix: str = "AI", format_instructions: str = FORMAT_INSTRUCTIONS):
-        self.ai_prefix = ai_prefix
-        self.format_instructions = format_instructions
-
-    def get_format_instructions(self) -> str:
-        """Returns formatting instructions for the given output parser."""
-        return self.format_instructions
-
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        """Parses outputted text from an LLM.
-
-        Args:
-            text (str): Outputted text to parse.
-
-        Returns:
-            Union[AgentAction, AgentFinish]: Parsed agent action or finish result
-        """
-        regex = r"Action: (.*?)[\n]*Action Input:([\s\S]*)"
-        match = re.search(regex, text, re.DOTALL)
-        if match is not None:
-            action = match.group(1)
-            action_input = match.group(2)
-            return AgentAction(action.strip(), action_input.strip(" ").strip('"'), text)
-        output = text
-        if f"{self.ai_prefix}:" in text:
-            output = text.split(f"{self.ai_prefix}:")[-1].strip()
-        return AgentFinish({"output": output}, text)
-
-    def extract_output(self, result: Union[AgentAction, AgentFinish, str]) -> str:
-        """Extract the actual output text from a parse result.
-
-        Args:
-            result: Result from parse() method or a string
-
-        Returns:
-            str: The actual output text
-        """
-        if isinstance(result, str):
-            return result
-        elif isinstance(result, AgentFinish):
-            return result.return_values.get("output", result.log)
-        elif isinstance(result, AgentAction):
-            # For AgentAction, return the log or tool_input
-            return result.tool_input if result.tool_input else result.log
-        else:
-            return str(result)
-
-    @property
-    def _type(self) -> str:
-        return "conversational"
diff --git a/mindsdb/integrations/utilities/rag/retrievers/sql_retriever.py b/mindsdb/integrations/utilities/rag/retrievers/sql_retriever.py
deleted file mode 100644
index 34d7a1e0b89..00000000000
--- a/mindsdb/integrations/utilities/rag/retrievers/sql_retriever.py
+++ /dev/null
@@ -1,949 +0,0 @@
-import re
-import math
-import logging
-import collections
-import json
-from typing import List, Any, Optional, Dict, Tuple, Union, Callable
-
-from pydantic import BaseModel, Field
-
-from mindsdb.integrations.utilities.rag.retrievers.base import BaseRetriever, RunnableRetriever
-from mindsdb.interfaces.knowledge_base.preprocessing.document_types import SimpleDocument
-
-from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
-from mindsdb.integrations.libs.response import HandlerResponse
-from mindsdb.integrations.libs.vectordatabase_handler import (
-    DistanceFunction,
-    VectorStoreHandler,
-)
-from mindsdb.integrations.utilities.rag.settings import (
-    DatabaseSchema,
-    TableSchema,
-    ColumnSchema,
-    ValueSchema,
-    SearchKwargs,
-)
-from mindsdb.utilities import log
-
-import numpy as np
-
-logger = log.getLogger(__name__)
-
-
-class MetadataFilter(BaseModel):
-    """Represents an LLM generated metadata filter to apply to a PostgreSQL query."""
-
-    attribute: str = Field(description="Database column to apply filter to")
-    comparator: str = Field(description="PostgreSQL comparator to use to filter database column")
-    value: Any = Field(description="Value to use to filter database column")
-
-
-class AblativeMetadataFilter(MetadataFilter):
-    """Adds additional fields to support ablation."""
-
-    schema_table: str = Field(description="schema name of the table for this filter")
-    schema_column: str = Field(description="schema name of the column for this filter")
-    schema_value: str = Field(description="schema name of the value for this filter")
-
-
-class MetadataFilters(BaseModel):
-    """List of LLM generated metadata filters to apply to a PostgreSQL query."""
-
-    filters: List[MetadataFilter] = Field(description="List of PostgreSQL metadata filters to apply for user query")
-
-
-class SQLRetriever(BaseRetriever):
-    """Retriever that uses a LLM to generate pgvector queries to do similarity search with metadata filters.
-
-    How it works:
-
-    1. Use a LLM to rewrite the user input to something more suitable for retrieval. For example:
-    "Show me documents containing how to finetune a LLM please" --> "how to finetune a LLM"
-
-    2. Use a LLM to generate structured metadata filters based on the user input. Provided
-    metadata schemas & examples are used as additional context.
-
-    3. Generate a prepared PostgreSQL query from the structured metadata filters.
-
-    4. Actually execute the query against our vector database to retrieve documents & return them.
-    """
-
-    fallback_retriever: Any  # Must have get_relevant_documents or invoke method
-    vector_store_handler: VectorStoreHandler
-    # search parameters
-    max_filters: int
-    filter_threshold: float
-    min_k: int
-
-    # Schema description
-    database_schema: Optional[DatabaseSchema] = None
-
-    # Embeddings
-    embeddings_model: Any  # Must have embed_query method
-    search_kwargs: SearchKwargs
-
-    # prompt templates
-    rewrite_prompt_template: str
-
-    # schema templates
-    table_prompt_template: str
-    column_prompt_template: str
-    value_prompt_template: str
-
-    # formatting templates
-    boolean_system_prompt: str
-    generative_system_prompt: str
-
-    # SQL search config
-    num_retries: int
-    embeddings_table: str
-    source_table: str
-    source_id_column: str
-    distance_function: DistanceFunction
-
-    # Re-rank and metadata generation model.
-    llm: Any  # Must have invoke method
-
-    def _sort_schema_by_priority_key(
-        self,
-        schema_dict_item: Tuple[str, Union[TableSchema, ColumnSchema, ValueSchema]],
-    ):
-        return schema_dict_item[1].priority
-
-    def _sort_schema_by_relevance_key(
-        self,
-        schema_dict_item: Tuple[str, Union[TableSchema, ColumnSchema, ValueSchema]],
-    ):
-        if schema_dict_item[1].relevance is not None:
-            return schema_dict_item[1].relevance
-        else:
-            return 0
-
-    def _sort_schema_by_key(
-        self,
-        schema: Union[DatabaseSchema, TableSchema, ColumnSchema],
-        key: Callable,
-        update: Dict[str, Any] = None,
-    ) -> Union[DatabaseSchema, TableSchema, ColumnSchema]:
-        """Takes a schema and converts its dict into an OrderedDict"""
-        if isinstance(schema, DatabaseSchema):
-            collection_key = "tables"
-        elif isinstance(schema, TableSchema):
-            collection_key = "columns"
-        elif isinstance(schema, ColumnSchema):
-            collection_key = "values"
-        else:
-            raise Exception("schema must be either a DatabaseSchema, TableSchema, or ColumnSchema.")
-
-        if update is not None:
-            ordered = collections.OrderedDict(sorted(update.items(), key=key, reverse=True))
-        else:
-            ordered = collections.OrderedDict(sorted(getattr(schema, collection_key).items(), key=key, reverse=True))
-        schema = schema.model_copy(update={collection_key: ordered})
-
-        return schema
-
-    def _sort_database_schema_by_key(self, database_schema: DatabaseSchema, key: Callable) -> DatabaseSchema:
-        """Re-build schema with OrderedDicts"""
-        tables = {}
-        # build new tables dict
-        for table_key, table_schema in database_schema.tables.items():
-            columns = {}
-            # build new column dict
-            for column_key, column_schema in table_schema.columns.items():
-                # sort values directly and update column schema
-                columns[column_key] = self._sort_schema_by_key(schema=column_schema, key=key)
-            # update table schema and sort
-            tables[table_key] = self._sort_schema_by_key(schema=table_schema, key=key, update=columns)
-        # update table schema and sort
-        database_schema = self._sort_schema_by_key(schema=database_schema, key=key, update=tables)
-
-        return database_schema
-
-    def _prepare_value_prompt(
-        self,
-        value_schema: ValueSchema,
-        column_schema: ColumnSchema,
-        table_schema: TableSchema,
-        boolean_system_prompt: bool = True,
-        format_instructions: Optional[str] = None,
-    ) -> str:
-        if boolean_system_prompt is True:
-            system_prompt = self.boolean_system_prompt
-        else:
-            system_prompt = self.generative_system_prompt
-
-        prepared_column_prompt = self._prepare_column_prompt(column_schema=column_schema, table_schema=table_schema)
-        # Extract column schema string from prepared prompt (it's now a string)
-        column_schema_str = (
-            prepared_column_prompt.split("Query:")[0] if "Query:" in prepared_column_prompt else prepared_column_prompt
-        )
-
-        value_str = ""
-        header_str = ""
-        if type(value_schema.value) in [str, int, float, bool]:
-            header_str = f"This schema describes a single value in the {column_schema.column} column."
-
-            value_str = f"""
- -**Value**: {value_schema.value}
-"""
-
-        elif type(value_schema.value) is dict:
-            header_str = f"This schema describes enumerated values in the {column_schema.column} column."
-
-            value_str = """
-## **Enumerated Values**
-
-The values in the column are an enumeration of named values. These are listed below with format **[Column Value]**: [named value].
-"""
-            for value, value_name in value_schema.value.items():
-                value_str += f"""
-- **{value}:** {value_name}"""
-
-        elif type(value_schema.value) is list:
-            header_str = f"This schema describes some of the values in the {column_schema.column} column."
-
-            value_str = """
-## **Sample Values**
-
-There are too many values in this column to list exhaustively. Below is a sampling of values found in the column:
-"""
-            for value in value_schema.value:
-                value_str += f"""
-- {value}"""
-
-        if getattr(value_schema, "comparator", None) is not None:
-            comparator_str = """
-
-## **Comparators**
-
-Below is a list of comparison operators for constructing filters for this value schema:
-"""
-            if type(value_schema.comparator) is str:
-                comparator_str += f"""- {value_schema.comparator}
-"""
-            else:
-                for comp in value_schema.comparator:
-                    comparator_str += f"""- {comp}
-"""
-        else:
-            comparator_str = ""
-
-        if getattr(value_schema, "example_questions", None) is not None:
-            example_str = """## **Example Questions**
-"""
-            for i, example in enumerate(value_schema.example_questions):
-                example_str += f"""{i}. **Query:** {example.input} **Answer:** {example.output}
-"""
-        else:
-            example_str = ""
-
-        # Format prompt as string instead of ChatPromptTemplate
-        format_instructions_str = format_instructions or ""
-        prompt = f"""{system_prompt}
-
-{self.value_prompt_template}
-
-Format Instructions:
-{format_instructions_str}
-
-Header:
-{header_str}
-
-Column Schema:
-{column_schema_str}
-
-Value:
-{value_str}
-
-Comparator:
-{comparator_str}
-
-Type: {value_schema.type}
-Description: {value_schema.description}
-Usage: {value_schema.usage}
-
-Examples:
-{example_str}
-
-Query: {{query}}"""
-        return prompt
-
-    def _prepare_column_prompt(
-        self,
-        column_schema: ColumnSchema,
-        table_schema: TableSchema,
-        boolean_system_prompt: bool = True,
-    ) -> str:
-        if boolean_system_prompt is True:
-            system_prompt = self.boolean_system_prompt
-        else:
-            system_prompt = self.generative_system_prompt
-
-        prepared_table_prompt = self._prepare_table_prompt(
-            table_schema=table_schema, boolean_system_prompt=boolean_system_prompt
-        )
-        # Extract table schema string from prepared prompt (it's now a string)
-        table_schema_str = (
-            prepared_table_prompt.split("Query:")[0] if "Query:" in prepared_table_prompt else prepared_table_prompt
-        )
-
-        header_str = f"This schema describes a column in the {table_schema.table} table."
-
-        value_str = """
-## **Content**
-
-Below is a description of the contents in this column in list format:
-"""
-        for value_schema in column_schema.values.values():
-            value_str += f"""
-- {value_schema.description}
-"""
-        value_str += """
-**Important:** The above descriptions are not the actual values stored in this column. See the Value schema for actual values.
-"""
-
-        if getattr(column_schema, "examples", None) is not None:
-            example_str = """## **Example Questions**
-"""
-            for example in column_schema.examples:
-                example_str += f"""- {example}
-"""
-        else:
-            example_str = ""
-
-        # Format prompt as string instead of ChatPromptTemplate
-        prompt = f"""{system_prompt}
-
-{self.column_prompt_template}
-
-Header:
-{header_str}
-
-Table Schema:
-{table_schema_str}
-
-Column: {column_schema.column}
-Type: {column_schema.type}
-Description: {column_schema.description}
-Usage: {column_schema.usage}
-
-Values:
-{value_str}
-
-Examples:
-{example_str}
-
-Query: {{query}}"""
-        return prompt
-
-    def _prepare_table_prompt(self, table_schema: TableSchema, boolean_system_prompt: bool = True) -> str:
-        if boolean_system_prompt is True:
-            system_prompt = self.boolean_system_prompt
-        else:
-            system_prompt = self.generative_system_prompt
-
-        header_str = "This schema describes a table in the database."
-
-        columns_str = ""
-        for column_key, column_schema in table_schema.columns.items():
-            columns_str += f"""
-- **{column_schema.column}:** {column_schema.description}
-"""
-
-        if getattr(table_schema, "examples", None) is not None:
-            example_str = """## **Example Questions**
-"""
-            for example in table_schema.examples:
-                example_str += f"""- {example}
-"""
-        else:
-            example_str = ""
-
-        # Format prompt as string instead of ChatPromptTemplate
-        prompt = f"""{system_prompt}
-
-{self.table_prompt_template}
-
-Header:
-{header_str}
-
-Table: {table_schema.table}
-Description: {table_schema.description}
-Usage: {table_schema.usage}
-
-Columns:
-{columns_str}
-
-Examples:
-{example_str}
-
-Query: {{query}}"""
-        return prompt
-
-    def _rank_schema(self, prompt: str, query: str) -> float:
-        """
-        Rank schema by calling LLM with prompt and query.
-
-        Args:
-            prompt: Prompt template string with {query} placeholder
-            query: Query string
-
-        Returns:
-            Relevance score between 0 and 1
-        """
-        # Format prompt with query
-        formatted_prompt = prompt.format(query=query)
-
-        try:
-            # Call LLM - try to get logprobs if supported
-            if hasattr(self.llm, "bind") and hasattr(self.llm.bind(logprobs=True), "invoke"):
-                llm_with_logprobs = self.llm.bind(logprobs=True)
-                output = llm_with_logprobs.invoke(formatted_prompt)
-            else:
-                # Fallback to regular invoke
-                output = self.llm.invoke(formatted_prompt)
-
-            # Try to extract logprobs from response
-            score = None
-            if hasattr(output, "response_metadata") and "logprobs" in output.response_metadata:
-                logprobs = output.response_metadata["logprobs"]
-                if "content" in logprobs:
-                    for content in logprobs["content"]:
-                        token = content.get("token", "").lower().strip()
-                        logprob = content.get("logprob", 0.0)
-                        if token == "yes":
-                            score = (1 + math.exp(logprob)) / 2
-                            break
-                        elif token == "no":
-                            score = (1 - math.exp(logprob)) / 2
-                            break
-
-            # If no logprobs, try to parse yes/no from content
-            if score is None:
-                content_text = ""
-                if hasattr(output, "content"):
-                    content_text = output.content.lower().strip()
-                elif isinstance(output, str):
-                    content_text = output.lower().strip()
-                else:
-                    content_text = str(output).lower().strip()
-
-                if "yes" in content_text:
-                    score = 0.75  # Default positive score
-                elif "no" in content_text:
-                    score = 0.25  # Default negative score
-                else:
-                    score = 0.5  # Neutral score
-
-            if score is None:
-                score = 0.0
-
-        except Exception as e:
-            logger.warning(f"Error ranking schema: {e}")
-            score = 0.0
-
-        return score
-
-    def _breadth_first_search(self, query: str, greedy: bool = False) -> Tuple:
-        """Search breadth wise through Tables, then Columns, then Values.Uses a greedy strategy to maximize quota if greedy=True, otherwise a dynamic strategy."""
-
-        # sort based on priority
-        ordered_database_schema = self._sort_database_schema_by_key(
-            database_schema=self.database_schema, key=self._sort_schema_by_priority_key
-        )
-
-        #  Rank Tables ########################################################
-        greedy_count = 0
-        tables = {}
-        # rank tables by relevance
-        for table_key, table_schema in ordered_database_schema.tables.items():
-            prompt: str = self._prepare_table_prompt(table_schema=table_schema, boolean_system_prompt=True)
-            table_schema.relevance = self._rank_schema(prompt=prompt, query=query)
-
-            # only keep greedy tables
-            tables[table_key] = table_schema
-
-            if greedy:
-                if table_schema.relevance >= ordered_database_schema.filter_threshold:
-                    greedy_count += 1
-                if greedy_count >= ordered_database_schema.max_filters:
-                    break
-
-        #  sort tables
-        ordered_database_schema = self._sort_schema_by_key(
-            schema=ordered_database_schema,
-            key=self._sort_schema_by_relevance_key,
-            update=tables,
-        )
-
-        #  Rank Columns #######################################################
-        #  iterate through tables to rank columns
-        tables = {}
-        table_count = 0  # take only the top n number of tables specified by the databases max filters
-        for table_key, table_schema in ordered_database_schema.tables.items():
-            # only drop into tables above the filter threshold
-            if table_schema.relevance >= ordered_database_schema.filter_threshold:
-                greedy_count = 0
-                # rank columns by relevance
-                columns = {}
-                for column_key, column_schema in table_schema.columns.items():
-                    prompt: str = self._prepare_column_prompt(
-                        column_schema=column_schema,
-                        table_schema=table_schema,
-                        boolean_system_prompt=True,
-                    )
-                    column_schema.relevance = self._rank_schema(prompt=prompt, query=query)
-
-                    columns[column_key] = column_schema
-
-                    if greedy:
-                        if column_schema.relevance >= table_schema.filter_threshold:
-                            greedy_count += 1
-                        if greedy_count >= table_schema.max_filters:
-                            break
-
-                # sort columns and keep only columns that made the cut.
-                tables[table_key] = self._sort_schema_by_key(
-                    table_schema, key=self._sort_schema_by_relevance_key, update=columns
-                )
-
-                table_count += 1
-                if table_count >= ordered_database_schema.max_filters:
-                    break
-
-        # sort tables and keep only tables that made the cut.
-        ordered_database_schema = self._sort_schema_by_key(
-            ordered_database_schema,
-            key=self._sort_schema_by_relevance_key,
-            update=tables,
-        )
-
-        #  Rank Values ########################################################
-        #  iterate through tables to rank values
-        tables = {}
-        for table_key, table_schema in ordered_database_schema.tables.items():
-            columns = {}
-            column_count = 0
-            # iterate through columns to rank values
-            for column_key, column_schema in table_schema.columns.items():
-                if column_schema.relevance >= table_schema.filter_threshold:
-                    greedy_count = 0
-                    values = {}
-                    #  rank values by relevance
-                    for value_key, value_schema in column_schema.values.items():
-                        prompt: str = self._prepare_value_prompt(
-                            value_schema=value_schema,
-                            column_schema=column_schema,
-                            table_schema=table_schema,
-                            boolean_system_prompt=True,
-                        )
-                        value_schema.relevance = self._rank_schema(prompt=prompt, query=query)
-
-                        values[value_key] = value_schema
-
-                        if greedy:
-                            if value_schema.relevance >= column_schema.filter_threshold:
-                                greedy_count += 1
-                            if greedy_count >= column_schema.max_filters:
-                                break
-
-                    # sort values and keep only values that make the cut
-                    columns[column_key] = self._sort_schema_by_key(
-                        column_schema,
-                        key=self._sort_schema_by_relevance_key,
-                        update=values,
-                    )
-
-                    column_count += 1
-                    if column_count >= table_schema.max_filters:
-                        break
-
-            # sort columns and keep only columns that made the cut
-            tables[table_key] = self._sort_schema_by_key(
-                table_schema, key=self._sort_schema_by_relevance_key, update=columns
-            )
-
-        # sort tables and keep only tables that made the cut.
-        ordered_database_schema = self._sort_schema_by_key(
-            ordered_database_schema,
-            key=self._sort_schema_by_relevance_key,
-            update=tables,
-        )
-
-        #  discard low ranked values ###################################################################################
-        tables = {}
-        for table_key, table_schema in ordered_database_schema.tables.items():
-            columns = {}
-            # iterate through columns to rank values
-            for column_key, column_schema in table_schema.columns.items():
-                value_count = 0
-                values = {}
-                #  rank values by relevance
-                for value_key, value_schema in column_schema.values.items():
-                    if value_schema.relevance >= column_schema.filter_threshold:
-                        values[value_key] = value_schema
-
-                        value_count += 1
-                        if value_count >= column_schema.max_filters:
-                            break
-
-                # sort values and keep only values that make the cut
-                columns[column_key] = self._sort_schema_by_key(
-                    column_schema,
-                    key=self._sort_schema_by_relevance_key,
-                    update=values,
-                )
-
-            # sort columns and keep only columns that made the cut
-            tables[table_key] = self._sort_schema_by_key(
-                table_schema, key=self._sort_schema_by_relevance_key, update=columns
-            )
-
-        # sort tables and keep only tables that made the cut.
-        ordered_database_schema = self._sort_schema_by_key(
-            ordered_database_schema,
-            key=self._sort_schema_by_relevance_key,
-            update=tables,
-        )
-
-        ranked_database_schema = ordered_database_schema
-
-        #  Build Ablation #####################################################
-
-        ablation_value_dict = {}
-        # assemble a relevance dictionary
-        for table_key, table_schema in ordered_database_schema.tables.items():
-            for column_key, column_schema in table_schema.columns.items():
-                for value_key, value_schema in column_schema.values.items():
-                    ablation_value_dict[(table_key, column_key, value_key)] = value_schema.relevance
-
-        ablation_value_dict = collections.OrderedDict(sorted(ablation_value_dict.items(), key=lambda x: x[1]))
-
-        relevance_scores = list(ablation_value_dict.values())
-        if len(relevance_scores) > 0:
-            ablation_quantiles = np.quantile(relevance_scores, np.linspace(0, 1, self.num_retries + 2)[1:-1])
-        else:
-            ablation_quantiles = None
-
-        return ranked_database_schema, ablation_value_dict, ablation_quantiles
-
-    def _dynamic_ablation(
-        self,
-        metadata_filters: List[AblativeMetadataFilter],
-        ablation_value_dict,
-        ablation_quantiles,
-        retry: int,
-    ):
-        """Ablate metadata filters in aggregate by quantiles until the required minimum number of documents are returned."""
-
-        ablated_dict = {}
-        for key, value in ablation_value_dict.items():
-            if value >= ablation_quantiles[retry]:
-                ablated_dict[key] = value
-
-        #  discard low ranked filters ##################################################################################
-        ablated_filters = []
-        for filter in metadata_filters:
-            for key in ablated_dict.keys():
-                if filter.schema_table in key and filter.schema_column in key and filter.schema_value in key:
-                    ablated_filters.append(filter)
-
-        return ablated_filters
-
-    def depth_first_search(self, greedy=True):
-        """Search depth wise through Tables, then Columns, then Values. Uses a greedy strategy to maximize quota if greedy=True, otherwise a dynamic strategy."""
-        pass
-
-    def depth_first_ablation(self):
-        """Ablate metadata filters in reverse depth first search until the required minimum number of documents are returned."""
-        pass
-
-    def _prepare_retrieval_query(self, query: str) -> str:
-        """Rewrite query to be suitable for retrieval using LLM"""
-        # Format prompt with query
-        formatted_prompt = self.rewrite_prompt_template.format(input=query)
-
-        # Call LLM
-        llm_response = self.llm.invoke(formatted_prompt)
-
-        # Extract content from LLM response
-        if hasattr(llm_response, "content"):
-            return llm_response.content
-        elif isinstance(llm_response, str):
-            return llm_response
-        else:
-            return str(llm_response)
-
-    def _prepare_pgvector_query(
-        self,
-        ranked_database_schema: DatabaseSchema,
-        metadata_filters: List[AblativeMetadataFilter],
-        retry: int = 0,
-    ) -> str:
-        # Base select JOINed with document source table.
-        base_query = f"""SELECT * FROM {self.embeddings_table} AS e INNER JOIN {self.source_table} AS s ON (e.metadata->>'original_row_id')::int = s."{self.source_id_column}" """
-
-        # return an empty string if schema has not been ranked
-        if not ranked_database_schema:
-            return ""
-
-        # Add Table JOIN statements
-        join_clauses = set()
-        for metadata_filter in metadata_filters:
-            join_clause = ranked_database_schema.tables[metadata_filter.schema_table].join
-            if join_clause in join_clauses:
-                continue
-            else:
-                join_clauses.add(join_clause)
-                base_query += join_clause + " "
-
-        # Add WHERE conditions from metadata filters
-        if metadata_filters:
-            base_query += "WHERE "
-        for i, filter in enumerate(metadata_filters):
-            value = filter.value
-            if isinstance(value, str):
-                value = f"'{value}'"
-            base_query += f'"{filter.attribute}" {filter.comparator} {value}'
-            if i < len(metadata_filters) - 1:
-                base_query += " AND "
-
-        base_query += (
-            f" ORDER BY e.embeddings {self.distance_function.value[0]} '{{embeddings}}' LIMIT {self.search_kwargs.k};"
-        )
-        return base_query
-
-    def _generate_filter(self, prompt: str, query: str) -> MetadataFilter:
-        """Generate metadata filter using LLM"""
-        # Format prompt with query
-        formatted_prompt = prompt.format(query=query)
-
-        # Call LLM
-        llm_response = self.llm.invoke(formatted_prompt)
-
-        # Extract content from LLM response
-        if hasattr(llm_response, "content"):
-            response_text = llm_response.content
-        elif isinstance(llm_response, str):
-            response_text = llm_response
-        else:
-            response_text = str(llm_response)
-
-        # Parse JSON response to get MetadataFilter
-        try:
-            parsed = json.loads(response_text)
-            # If it's a dict, try to create MetadataFilter
-            if isinstance(parsed, dict):
-                return MetadataFilter(**parsed)
-            else:
-                # If it's already a MetadataFilter-like object
-                return parsed
-        except (json.JSONDecodeError, TypeError, Exception) as e:
-            logger.warning(f"Error parsing filter response: {e}")
-            # Return empty filter on error
-            return MetadataFilter(attribute="", comparator="=", value="")
-
-    def _generate_metadata_filters(
-        self, query: str, ranked_database_schema
-    ) -> Union[List[AblativeMetadataFilter], HandlerResponse]:
-        """Generate metadata filters using LLM"""
-
-        metadata_filter_list = []
-        #  iterate through tables to rank values
-        for table_key, table_schema in ranked_database_schema.tables.items():
-            # iterate through columns to rank values
-            for column_key, column_schema in table_schema.columns.items():
-                if column_schema.relevance >= table_schema.filter_threshold:
-                    #  generate filters
-                    for value_key, value_schema in column_schema.values.items():
-                        # must use generation if field is a dictionary of tuples or a list
-                        if type(value_schema.value) in [list, dict]:
-                            try:
-                                # Create format instructions for JSON output
-                                format_instructions = """Return a JSON object with the following structure:
-{
-  "attribute": "column_name",
-  "comparator": "comparison_operator",
-  "value": "filter_value"
-}"""
-
-                                metadata_prompt: str = self._prepare_value_prompt(
-                                    format_instructions=format_instructions,
-                                    value_schema=value_schema,
-                                    column_schema=column_schema,
-                                    table_schema=table_schema,
-                                    boolean_system_prompt=False,
-                                )
-
-                                # Call LLM directly
-                                formatted_prompt = metadata_prompt.format(query=query)
-                                llm_response = self.llm.invoke(formatted_prompt)
-
-                                # Extract content from LLM response
-                                if hasattr(llm_response, "content"):
-                                    metadata_filter_output = llm_response.content
-                                elif isinstance(llm_response, str):
-                                    metadata_filter_output = llm_response
-                                else:
-                                    metadata_filter_output = str(llm_response)
-
-                                # If the LLM outputs raw JSON, use it as-is.
-                                # If the LLM outputs anything including a json markdown section, use the last one.
-                                json_markdown_output = re.findall(r"```json.*?```", metadata_filter_output, re.DOTALL)
-                                if json_markdown_output:
-                                    metadata_filter_output = json_markdown_output[-1]
-                                    # Clean the json tags.
-                                    metadata_filter_output = metadata_filter_output[7:]
-                                    metadata_filter_output = metadata_filter_output[:-3]
-
-                                # Parse JSON directly instead of using PydanticOutputParser
-                                parsed = json.loads(metadata_filter_output.strip())
-                                model_dump = {
-                                    "attribute": parsed.get("attribute", ""),
-                                    "comparator": parsed.get("comparator", "="),
-                                    "value": parsed.get("value", ""),
-                                    "schema_table": table_key,
-                                    "schema_column": column_key,
-                                    "schema_value": value_key,
-                                }
-                                metadata_filter = AblativeMetadataFilter(**model_dump)
-                            except (json.JSONDecodeError, TypeError, Exception) as e:
-                                logger.warning(
-                                    f"LLM failed to generate structured metadata filters: {e}",
-                                    exc_info=logger.isEnabledFor(logging.DEBUG),
-                                )
-                                return HandlerResponse(RESPONSE_TYPE.ERROR, error_message=str(e))
-                        else:
-                            metadata_filter = AblativeMetadataFilter(
-                                attribute=column_schema.column,
-                                comparator=value_schema.comparator,
-                                value=value_schema.value,
-                                schema_table=table_key,
-                                schema_column=column_key,
-                                schema_value=value_key,
-                            )
-                        metadata_filter_list.append(metadata_filter)
-
-        return metadata_filter_list
-
-    def _prepare_and_execute_query(
-        self,
-        ranked_database_schema: DatabaseSchema,
-        metadata_filters: List[AblativeMetadataFilter],
-        embeddings_str: str,
-    ) -> HandlerResponse:
-        try:
-            checked_sql_query = self._prepare_pgvector_query(ranked_database_schema, metadata_filters)
-            checked_sql_query_with_embeddings = checked_sql_query.format(embeddings=embeddings_str)
-            return self.vector_store_handler.native_query(checked_sql_query_with_embeddings)
-        except Exception as e:
-            logger.warning(
-                f"Failed to prepare and execute SQL query from structured metadata: {e}",
-                exc_info=logger.isEnabledFor(logging.DEBUG),
-            )
-            return HandlerResponse(RESPONSE_TYPE.ERROR, error_message=str(e))
-
-    def _get_relevant_documents(self, query: str, *, run_manager: Optional[Any] = None) -> List[Any]:
-        # Rewrite query to be suitable for retrieval.
-        retrieval_query = self._prepare_retrieval_query(query)
-
-        # Embed the rewritten retrieval query & include it in the similarity search pgvector query.
-        embedded_query = self.embeddings_model.embed_query(retrieval_query)
-
-        # Search for relevant filters
-        ranked_database_schema, ablation_value_dict, ablation_quantiles = self._breadth_first_search(query=query)
-
-        # Generate metadata filters
-        metadata_filters = self._generate_metadata_filters(query=query, ranked_database_schema=ranked_database_schema)
-
-        if type(metadata_filters) is list:
-            # Initial Execution of the similarity search with metadata filters.
-            document_response = self._prepare_and_execute_query(
-                ranked_database_schema=ranked_database_schema,
-                metadata_filters=metadata_filters,
-                embeddings_str=str(embedded_query),
-            )
-            num_retries = 0
-            while num_retries < self.num_retries:
-                if (
-                    document_response.resp_type != RESPONSE_TYPE.ERROR
-                    and len(document_response.data_frame) >= self.min_k
-                ):
-                    # Successfully retrieved k documents to send to re-ranker.
-                    break
-                elif document_response.resp_type == RESPONSE_TYPE.ERROR:
-                    # LLMs won't always generate structured metadata so we should have a fallback after retrying.
-                    logger.info(f"SQL Retriever query failed with error {document_response.error_message}")
-                else:
-                    logger.info(
-                        f"SQL Retriever did not retrieve {self.min_k} documents: {len(document_response.data_frame)} documents retrieved."
-                    )
-
-                ablated_metadata_filters = self._dynamic_ablation(
-                    metadata_filters=metadata_filters,
-                    ablation_value_dict=ablation_value_dict,
-                    ablation_quantiles=ablation_quantiles,
-                    retry=num_retries,
-                )
-
-                document_response = self._prepare_and_execute_query(
-                    ranked_database_schema=ranked_database_schema,
-                    metadata_filters=ablated_metadata_filters,
-                    embeddings_str=str(embedded_query),
-                )
-
-                num_retries += 1
-
-            retrieved_documents = []
-            if document_response.resp_type != RESPONSE_TYPE.ERROR:
-                document_df = document_response.data_frame
-                for _, document_row in document_df.iterrows():
-                    retrieved_documents.append(
-                        SimpleDocument(
-                            page_content=document_row.get("content", ""),
-                            metadata=document_row.get("metadata", {}),
-                        )
-                    )
-            if retrieved_documents:
-                return retrieved_documents
-
-            # If the SQL query constructed did not return any documents, fallback.
-            logger.info("No documents returned from SQL retriever, using fallback retriever.")
-            return self._retrieve_from_fallback_retriever(retrieval_query)
-        else:
-            # If no metadata fields could be generated fallback.
-            logger.info("No metadata fields were successfully generated, using fallback retriever.")
-            return self._retrieve_from_fallback_retriever(retrieval_query)
-
-    def _retrieve_from_fallback_retriever(self, query: str) -> List[Any]:
-        """Retrieve documents from fallback retriever using duck typing"""
-        if hasattr(self.fallback_retriever, "_get_relevant_documents"):
-            return self.fallback_retriever._get_relevant_documents(query)
-        elif hasattr(self.fallback_retriever, "get_relevant_documents"):
-            return self.fallback_retriever.get_relevant_documents(query)
-        elif hasattr(self.fallback_retriever, "invoke"):
-            return self.fallback_retriever.invoke(query)
-        else:
-            raise ValueError(
-                "Fallback retriever must have _get_relevant_documents, get_relevant_documents, or invoke method"
-            )
-
-    def invoke(self, query: str) -> List[Any]:
-        """Sync invocation - retrieve documents for a query"""
-        return self._get_relevant_documents(query)
-
-    async def ainvoke(self, query: str) -> List[Any]:
-        """Async invocation - retrieve documents for a query"""
-        import asyncio
-
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, self._get_relevant_documents, query)
-
-    def get_relevant_documents(self, query: str) -> List[Any]:
-        """Get relevant documents (sync)"""
-        return self._get_relevant_documents(query)
-
-    def as_runnable(self) -> RunnableRetriever:
-        """Return self as a runnable retriever"""
-        return self
diff --git a/mindsdb/integrations/utilities/rag/settings.py b/mindsdb/integrations/utilities/rag/settings.py
index 56a8306295f..c4eb9a6a162 100644
--- a/mindsdb/integrations/utilities/rag/settings.py
+++ b/mindsdb/integrations/utilities/rag/settings.py
@@ -1,366 +1,20 @@
 from enum import Enum
-from typing import List, Union, Any, Optional, Dict, OrderedDict
+from typing import List, Any, Optional, Dict
 
-from pydantic import BaseModel, Field, field_validator, ConfigDict
-from mindsdb.integrations.utilities.rag.splitters.custom_splitters import RecursiveCharacterTextSplitter as TextSplitter
-from mindsdb.integrations.utilities.rag.loaders.vector_store_loader.base_vector_store import VectorStore
+from pydantic import BaseModel, Field, ConfigDict
 
-DEFAULT_COLLECTION_NAME = "default_collection"
 
-# Multi retriever specific
-DEFAULT_ID_KEY = "doc_id"
-DEFAULT_MAX_CONCURRENCY = 5
-DEFAULT_K = 20
-
-DEFAULT_CARDINALITY_THRESHOLD = 40
-DEFAULT_MAX_SUMMARIZATION_TOKENS = 4000
 DEFAULT_CHUNK_SIZE = 1000
 DEFAULT_CHUNK_OVERLAP = 200
-DEFAULT_POOL_RECYCLE = 3600
 DEFAULT_LLM_MODEL = "gpt-4o"
+DEFAULT_LLM_ENDPOINT = "https://api.openai.com/v1"
 DEFAULT_LLM_MODEL_PROVIDER = "openai"
-DEFAULT_CONTENT_COLUMN_NAME = "body"
-DEFAULT_DATASET_DESCRIPTION = "email inbox"
-DEFAULT_TEST_TABLE_NAME = "test_email"
-DEFAULT_RERANKER_FLAG = False
 DEFAULT_RERANKING_MODEL = "gpt-4o"
-DEFAULT_LLM_ENDPOINT = "https://api.openai.com/v1"
 DEFAULT_RERANKER_N = 1
 DEFAULT_RERANKER_LOGPROBS = True
 DEFAULT_RERANKER_TOP_LOGPROBS = 4
 DEFAULT_RERANKER_MAX_TOKENS = 100
 DEFAULT_VALID_CLASS_TOKENS = ["1", "2", "3", "4"]
-DEFAULT_AUTO_META_PROMPT_TEMPLATE = """
-Below is a json representation of a table with information about {description}.
-Return a JSON list with an entry for each column. Each entry should have
-{{"name": "column name", "description": "column description", "type": "column data type"}}
-\n\n{dataframe}\n\nJSON:\n
-"""
-DEFAULT_RAG_PROMPT_TEMPLATE = """You are an assistant for
-question-answering tasks. Use the following pieces of retrieved context
-to answer the question. If you don't know the answer, just say that you
-don't know. Use two sentences maximum and keep the answer concise.
-Question: {question}
-Context: {context}
-Answer:"""
-
-DEFAULT_QA_GENERATION_PROMPT_TEMPLATE = """You are an assistant for
-generating sample questions and answers from the given document and metadata. Given
-a document and its metadata as context, generate a question and answer from that document and its metadata.
-
-The document will be a string. The metadata will be a JSON string. You need
-to parse the JSON to understand it.
-
-Generate a question that requires BOTH the document and metadata to answer, if possible.
-Otherwise, generate a question that requires ONLY the document to answer.
-
-Return a JSON dictionary with the question and answer like this:
-{{ "question": <the full generated question>, "answer": <the full generated answer> }}
-
-Make sure the JSON string is valid before returning it. You must return the question and answer
-in the specified JSON format no matter what.
-
-Document: {document}
-Metadata: {metadata}
-Answer:"""
-
-DEFAULT_MAP_PROMPT_TEMPLATE = """The following is a set of documents
-{docs}
-Based on this list of docs, please summarize based on the user input.
-
-User input: {input}
-
-Helpful Answer:"""
-
-DEFAULT_REDUCE_PROMPT_TEMPLATE = """The following is set of summaries:
-{docs}
-Take these and distill it into a final, consolidated summary related to the user input.
-
-User input: {input}
-
-Helpful Answer:"""
-
-DEFAULT_SEMANTIC_PROMPT_TEMPLATE = """Provide a better search query for web search engine to answer the given question.
-
-<< EXAMPLES >>
-1. Input: "Show me documents containing how to finetune a LLM please"
-Output: "how to finetune a LLM"
-
-Output only a single better search query and nothing else like in the example.
-
-Here is the user input: {input}
-"""
-
-DEFAULT_METADATA_FILTERS_PROMPT_TEMPLATE = """Construct a list of PostgreSQL metadata filters to filter documents in the database based on the user input.
-
-<< INSTRUCTIONS >>
-{format_instructions}
-
-RETURN ONLY THE FINAL JSON. DO NOT EXPLAIN, JUST RETURN THE FINAL JSON.
-
-<< TABLES YOU HAVE ACCESS TO >>
-
-{schema}
-
-<< EXAMPLES >>
-
-{examples}
-
-Here is the user input:
-{input}
-"""
-
-DEFAULT_BOOLEAN_PROMPT_TEMPLATE = """**Task:** Determine Schema Relevance for Database Search Queries
-
-As an expert in constructing database search queries, you are provided with database schemas detailing tables, columns, and values. Your task is to assess whether these elements can be used to effectively search the database in relation to a given user query.
-
-**Instructions:**
-
-- **Evaluate the Schema**:
-  - Analyze the tables, columns, and values described.
-  - Consider their potential usefulness in retrieving information pertinent to the user query.
-
-- **Decision Criteria**:
-  - Determine if any part of the schema could assist in forming a relevant search query for the information requested.
-
-- **Response**:
-  - Reply with a single word: 'yes' if the schema components are useful, otherwise 'no'.
-
-**Note:** Provide your answer based solely on the relevance of the described schema to the user query."""
-
-DEFAULT_GENERATIVE_SYSTEM_PROMPT = """You are an expert database analyst that can assist in building SQL queries by providing structured output. Follow these format instructions precisely to generate a metadata filter given the provided schema description.
-
-## Format instructions:
-{format_instructions}
- """
-
-DEFAULT_VALUE_PROMPT_TEMPLATE = """
-{column_schema}
-
-# **Value Schema**
-{header}
-
-- The type of the value: {type}
-
-## **Description**
-{description}
-
-{value}{comparator}
-
-## **Usage**
-{usage}
-
-{examples}
-
-## **Query**
-{query}
-
-"""
-
-DEFAULT_COLUMN_PROMPT_TEMPLATE = """
-{table_schema}
-
-# **Column Schema**
-{header}
-
-- The column name in the database table: {column}
-- The type of the values in this column: {type}
-
-## **Description**
-{description}
-
-## **Usage**
-{usage}
-
-{examples}
-
-## **Query**
-{query}
-"""
-
-DEFAULT_TABLE_PROMPT_TEMPLATE = """# **Table Schema**
-{header}
-
-- The name of this table in the database: {table}
-
-## **Description**
-{description}
-
-## **Usage**
-{usage}
-
-## **Column Descriptions**
-Below are descriptions of each column in this table:
-
-{columns}
-
-{examples}
-
-## **Query**
-{query}
-"""
-
-DEFAULT_SQL_PROMPT_TEMPLATE = """
-Construct a valid {dialect} SQL query to select documents relevant to the user input.
-Source documents are found in the {source_table} table. You may need to join with other tables to get additional document metadata.
-
-The JSON col "metadata" in the {embeddings_table} has a string field called "original_row_id". This "original_row_id" string field in the
-"metadata" col is the document ID associated with a row in the {embeddings_table} table.
-You MUST always join with the {embeddings_table} table containing vector embeddings for the documents. For example, for a table named sd with an id column "Id":
-JOIN {embeddings_table} v ON (v."metadata"->>'original_row_id')::int = sd."Id"
-
-You MUST always order the embeddings by the {distance_function} comparator with '{{embeddings}}'.
-You MUST always limit by {k} returned documents.
-For example:
-ORDER BY v.embeddings {distance_function} '{{embeddings}}' LIMIT {k};
-
-
-<< TABLES YOU HAVE ACCESS TO >>
-1. {embeddings_table} - Contains document chunks, vector embeddings, and metadata for documents.
-You MUST always include the metadata column in your SELECT statement.
-You MUST always join with the {embeddings_table} table containing vector embeddings for the documents.
-You MUST always order by the provided embeddings vector using the {distance_function} comparator.
-You MUST always limit by {k} returned documents.
-
-Columns:
-```json
-{{
-    "id": {{
-        "type": "string",
-        "description": "Unique ID for this document chunk"
-    }},
-    "content": {{
-        "type": "string",
-        "description": "A document chunk (subset of the original document)"
-    }},
-    "embeddings": {{
-        "type": "vector",
-        "description": "Vector embeddings for the document chunk. ALWAYS order by the provided embeddings vector using the {distance_function} comparator."
-    }},
-    "metadata": {{
-        "type": "jsonb",
-        "description": "Metadata for the document chunk. Always select metadata and always join with the {source_table} table on the string metadata field 'original_row_id'"
-    }}
-}}
-
-{schema}
-
-<< EXAMPLES >>
-
-{examples}
-
-Output the {dialect} SQL query that is ready to be executed only WITHOUT ANY DELIMITERS. Make sure to properly quote identifiers.
-
-Here is the user input:
-{input}
-"""
-
-DEFAULT_QUESTION_REFORMULATION_TEMPLATE = """Given the original question and the retrieved context,
-analyze what additional information is needed for a complete, accurate answer.
-
-Original Question: {question}
-
-Retrieved Context:
-{context}
-
-Analysis Instructions:
-1. Evaluate Context Coverage:
-   - Identify key entities and concepts from the question
-   - Check for temporal information (dates, periods, sequences)
-   - Verify causal relationships are explained
-   - Confirm presence of requested quantitative data
-   - Assess if geographic or spatial context is sufficient
-
-2. Quality Assessment:
-   If the retrieved context is:
-   - Irrelevant or tangential
-   - Too general or vague
-   - Potentially contradictory
-   - Missing key perspectives
-   - Lacking proper evidence
-   Generate questions to address these specific gaps.
-
-3. Follow-up Question Requirements:
-   - Questions must directly contribute to answering the original query
-   - Break complex relationships into simpler, sequential steps
-   - Maintain specificity rather than broad inquiries
-   - Avoid questions answerable from existing context
-   - Ensure questions build on each other logically
-   - Limit questions to 150 characters each
-   - Each question must be self-contained
-   - Questions must end with a question mark
-
-4. Response Format:
-   - Return a JSON array of strings
-   - Use square brackets and double quotes
-   - Questions must be unique (no duplicates)
-   - If context is sufficient, return empty array []
-   - Maximum 3 follow-up questions
-   - Minimum length per question: 30 characters
-   - No null values or empty strings
-
-Example:
-Original: "How did the development of antibiotics affect military casualties in WWII?"
-
-Invalid responses:
-{'questions': ['What are antibiotics?']}  // Wrong format
-['What is WWII?']  // Too basic
-['How did it impact things?']  // Too vague
-['', 'Question 2']  // Contains empty string
-['Same question?', 'Same question?']  // Duplicate
-
-Valid response:
-["What were military casualty rates from infections before widespread antibiotic use in 1942?",
- "How did penicillin availability change throughout different stages of WWII?",
- "What were the primary battlefield infections treated with antibiotics during WWII?"]
-
-or [] if context fully answers the original question.
-
-Your task: Based on the analysis of the original question and context,
-output ONLY a JSON array of follow-up questions needed to provide a complete answer.
-If no additional information is needed, output an empty array [].
-
-Follow-up Questions:"""
-
-DEFAULT_QUERY_RETRY_PROMPT_TEMPLATE = """
-{query}
-
-The {dialect} query above failed with the error message: {error}.
-
-<< TABLES YOU HAVE ACCESS TO >>
-1. {embeddings_table} - Contains document chunks, vector embeddings, and metadata for documents.
-
-Columns:
-```json
-{{
-    "id": {{
-        "type": "string",
-        "description": "Unique ID for this document chunk"
-    }},
-    "content": {{
-        "type": "string",
-        "description": "A document chunk (subset of the original document)"
-    }},
-    "embeddings": {{
-        "type": "vector",
-        "description": "Vector embeddings for the document chunk."
-    }},
-    "metadata": {{
-        "type": "jsonb",
-        "description": "Metadata for the document chunk."
-    }}
-}}
-
-{schema}
-
-Rewrite the query so it works.
-
-Output the final SQL query only.
-
-SQL Query:
-"""
-
-DEFAULT_NUM_QUERY_RETRIES = 2
 
 
 class LLMConfig(BaseModel):
@@ -373,313 +27,6 @@ class LLMConfig(BaseModel):
     model_config = ConfigDict(protected_namespaces=())
 
 
-class MultiVectorRetrieverMode(Enum):
-    """
-    Enum for MultiVectorRetriever types.
-    """
-
-    SPLIT = "split"
-    SUMMARIZE = "summarize"
-    BOTH = "both"
-
-
-class VectorStoreType(Enum):
-    CHROMA = "chromadb"
-    PGVECTOR = "pgvector"
-
-
-class VectorStoreConfig(BaseModel):
-    vector_store_type: VectorStoreType = VectorStoreType.CHROMA
-    persist_directory: str = None
-    collection_name: str = DEFAULT_COLLECTION_NAME
-    connection_string: str = None
-    kb_table: Any = None
-    is_sparse: bool = False
-    vector_size: Optional[int] = None
-
-    class Config:
-        arbitrary_types_allowed = True
-        extra = "forbid"
-
-
-class RetrieverType(str, Enum):
-    """Retriever type for RAG pipeline"""
-
-    VECTOR_STORE = "vector_store"
-    AUTO = "auto"
-    MULTI = "multi"
-    SQL = "sql"
-    MULTI_HOP = "multi_hop"
-
-
-class SearchType(Enum):
-    """
-    Enum for vector store search types.
-    """
-
-    SIMILARITY = "similarity"
-    MMR = "mmr"
-    SIMILARITY_SCORE_THRESHOLD = "similarity_score_threshold"
-
-
-class SearchKwargs(BaseModel):
-    k: int = Field(default=DEFAULT_K, description="Amount of documents to return", ge=1)
-    filter: Optional[Dict[str, Any]] = Field(default=None, description="Filter by document metadata")
-    # For similarity_score_threshold search type
-    score_threshold: Optional[float] = Field(
-        default=None,
-        description="Minimum relevance threshold for similarity_score_threshold search",
-        ge=0.0,
-        le=1.0,
-    )
-    # For MMR search type
-    fetch_k: Optional[int] = Field(default=None, description="Amount of documents to pass to MMR algorithm", ge=1)
-    lambda_mult: Optional[float] = Field(
-        default=None,
-        description="Diversity of results returned by MMR (1=min diversity, 0=max)",
-        ge=0.0,
-        le=1.0,
-    )
-
-    def model_dump(self, *args, **kwargs):
-        # Override model_dump to exclude None values by default
-        kwargs["exclude_none"] = True
-        return super().model_dump(*args, **kwargs)
-
-
-class LLMExample(BaseModel):
-    input: str = Field(description="User input for the example")
-    output: str = Field(description="What the LLM should generate for this example's input")
-
-
-class ValueSchema(BaseModel):
-    value: Union[
-        Union[str, int, float],
-        Dict[Union[str, int, float], str],
-        List[Union[str, int, float]],
-    ] = Field(
-        description="One of the following. The value as it exists in the table column. A dict of {table_value: descriptive value, ...}, where table_value is the value in the table. A list of sample values taken from the column."
-    )
-    comparator: Optional[Union[str, List[str]]] = Field(
-        description="The posgtres sql operators used to compare two values. For example: `>`, `<`, `=`, or `%`.",
-        default="=",
-    )
-    type: str = Field(
-        description="A valid postgres type for this value. One of: int, string, float, or bool. When numbers appear they should be of type int or float."
-    )
-    description: str = Field(description="Description of what the value represents.")
-    usage: str = Field(description="How and when to use this value for search.")
-    example_questions: Optional[List[LLMExample]] = Field(
-        default=None, description="Example questions where this value is set."
-    )
-    filter_threshold: Optional[float] = Field(
-        default=0.0,
-        description="Minimum relevance threshold to include metadata filters from this column.",
-        exclude=True,
-    )
-    priority: Optional[int] = Field(
-        default=0,
-        description="Priority level for this column, lower numbers will be processed first.",
-    )
-    relevance: Optional[float] = Field(
-        default=None,
-        description="Relevance computed during search. Should not be set by the end user.",
-        exclude=True,
-    )
-
-
-class MetadataConfig(BaseModel):
-    """Class to configure metadata for retrieval. Only supports very basic document name lookup at the moment."""
-
-    table: str = Field(description="Source table for metadata.")
-    max_document_context: int = Field(
-        # To work well with models with context window of 32768.
-        default=16384,
-        description="Truncate a document before using as context with an LLM if it exceeds this amount of tokens",
-    )
-    embeddings_table: str = Field(default="embeddings", description="Source table for embeddings")
-    id_column: str = Field(default="Id", description="Name of ID column in metadata table")
-    name_column: str = Field(default="Title", description="Name of column containing name or title of document")
-    name_column_index: Optional[str] = Field(default=None, description="Name of GIN index to use when looking up name.")
-    content_column: str = Field(
-        default="content", description="Name of column in embeddings table containing chunk content"
-    )
-    embeddings_metadata_column: str = Field(
-        default="metadata", description="Name of column in embeddings table containing chunk metadata"
-    )
-    doc_id_key: str = Field(
-        default="original_row_id", description="Metadata field that links an embedded chunk back to source document ID"
-    )
-
-
-class ColumnSchema(BaseModel):
-    column: str = Field(description="Name of the column in the database")
-    type: str = Field(description="Type of the column (e.g. int, string, datetime)")
-    description: str = Field(description="Description of what the column represents")
-    usage: str = Field(description="How and when to use this Table for search.")
-    values: Optional[
-        Union[
-            OrderedDict[Union[str, int, float], ValueSchema],
-            Dict[Union[str, int, float], ValueSchema],
-        ]
-    ] = Field(
-        default=None,
-        description="One of the following. A dict or ordered dict of {schema_value: ValueSchema, ...}, where schema value is the name given for this value description in the schema.",
-    )
-    example_questions: Optional[List[LLMExample]] = Field(
-        default=None, description="Example questions where this table is useful."
-    )
-    max_filters: Optional[int] = Field(default=1, description="Maximum number of filters to generate for this column.")
-    filter_threshold: Optional[float] = Field(
-        default=0.0,
-        description="Minimum relevance threshold to include metadata filters from this column.",
-    )
-    priority: Optional[int] = Field(
-        default=1,
-        description="Priority level for this column, lower numbers will be processed first.",
-    )
-    relevance: Optional[float] = Field(
-        default=None,
-        description="Relevance computed during search. Should not be set by the end user.",
-    )
-
-
-class TableSchema(BaseModel):
-    table: str = Field(description="Name of table in the database")
-    description: str = Field(description="Description of what the table represents")
-    usage: str = Field(description="How and when to use this Table for search.")
-    columns: Optional[Union[OrderedDict[str, ColumnSchema], Dict[str, ColumnSchema]]] = Field(
-        description="Dict or Ordered Dict of {column_name: ColumnSchemas} describing the metadata columns available for the table"
-    )
-    example_questions: Optional[List[LLMExample]] = Field(
-        default=None, description="Example questions where this table is useful."
-    )
-    join: str = Field(
-        description="SQL join string to join this table with source documents table",
-        default="",
-    )
-    max_filters: Optional[int] = Field(default=1, description="Maximum number of filters to generate for this table.")
-    filter_threshold: Optional[float] = Field(
-        default=0.0,
-        description="Minimum relevance required to use this table to generate filters.",
-    )
-    priority: Optional[int] = Field(
-        default=1,
-        description="Priority level for this table, lower numbers will be processed first.",
-    )
-    relevance: Optional[float] = Field(
-        default=None,
-        description="Relevance computed during search. Should not be set by the end user.",
-    )
-
-
-class DatabaseSchema(BaseModel):
-    database: str = Field(description="Name of database in the Database")
-    description: str = Field(description="Description of what the Database represents")
-    usage: str = Field(description="How and when to use this Database for search.")
-    tables: Union[OrderedDict[str, TableSchema], Dict[str, TableSchema]] = Field(
-        description="Dict of {column_name: ColumnSchemas} describing the metadata columns available for the table"
-    )
-    example_questions: Optional[List[LLMExample]] = Field(
-        default=None, description="Example questions where this Database is useful."
-    )
-    max_filters: Optional[int] = Field(
-        default=1,
-        description="Maximum number of filters to generate for this Database.",
-    )
-    filter_threshold: Optional[float] = Field(
-        default=0.0,
-        description="Minimum relevance required to use this Database to generate filters.",
-    )
-    priority: Optional[int] = Field(
-        default=0,
-        description="Priority level for this Database, lower numbers will be processed first.",
-    )
-    relevance: Optional[float] = Field(
-        default=None,
-        description="Relevance computed during search. Should not be set by the end user.",
-    )
-
-
-class SQLRetrieverConfig(BaseModel):
-    llm_config: LLMConfig = Field(
-        default_factory=LLMConfig,
-        description="LLM configuration to use for generating the final SQL query for retrieval",
-    )
-    metadata_filters_prompt_template: str = Field(
-        default=DEFAULT_METADATA_FILTERS_PROMPT_TEMPLATE,
-        description="Prompt template to generate PostgreSQL metadata filters. Has 'format_instructions', 'schema', 'examples', and 'input' input variables",
-    )
-    num_retries: int = Field(
-        default=DEFAULT_NUM_QUERY_RETRIES,
-        description="How many times for an LLM to try rewriting a failed SQL query before using the fallback retriever.",
-    )
-    rewrite_prompt_template: str = Field(
-        default=DEFAULT_SEMANTIC_PROMPT_TEMPLATE,
-        description="Prompt template to rewrite user input to be better suited for retrieval. Has 'input' input variable.",
-    )
-    table_prompt_template: str = Field(
-        default=DEFAULT_TABLE_PROMPT_TEMPLATE,
-        description="Prompt template to rewrite user input to be better suited for retrieval. Has 'input' input variable.",
-    )
-    column_prompt_template: str = Field(
-        default=DEFAULT_COLUMN_PROMPT_TEMPLATE,
-        description="Prompt template to rewrite user input to be better suited for retrieval. Has 'input' input variable.",
-    )
-    value_prompt_template: str = Field(
-        default=DEFAULT_VALUE_PROMPT_TEMPLATE,
-        description="Prompt template to rewrite user input to be better suited for retrieval. Has 'input' input variable.",
-    )
-    boolean_system_prompt: str = Field(
-        default=DEFAULT_BOOLEAN_PROMPT_TEMPLATE,
-        description="Prompt template to rewrite user input to be better suited for retrieval. Has 'input' input variable.",
-    )
-    generative_system_prompt: str = Field(
-        default=DEFAULT_GENERATIVE_SYSTEM_PROMPT,
-        description="Prompt template to rewrite user input to be better suited for retrieval. Has 'input' input variable.",
-    )
-    source_table: str = Field(
-        description="Name of the source table containing the original documents that were embedded"
-    )
-    source_id_column: str = Field(description="Name of the column containing the UUID.", default="Id")
-    max_filters: Optional[int] = Field(description="Maximum number of filters to generate for sql queries.", default=10)
-    filter_threshold: Optional[float] = Field(
-        description="Minimum relevance required to use this Database to generate filters.",
-        default=0.0,
-    )
-    min_k: Optional[int] = Field(
-        description="Minimum number of documents accepted from a generated sql query.",
-        default=10,
-    )
-    database_schema: Optional[DatabaseSchema] = Field(
-        default=None,
-        description="DatabaseSchema describing the database.",
-    )
-    examples: Optional[List[LLMExample]] = Field(
-        default=None,
-        description="Optional examples of final generated pgvector queries based on user input.",
-    )
-
-
-class SummarizationConfig(BaseModel):
-    llm_config: LLMConfig = Field(
-        default_factory=LLMConfig,
-        description="LLM configuration to use for summarization",
-    )
-    map_prompt_template: str = Field(
-        default=DEFAULT_MAP_PROMPT_TEMPLATE,
-        description="Prompt for an LLM to summarize a single document",
-    )
-    reduce_prompt_template: str = Field(
-        default=DEFAULT_REDUCE_PROMPT_TEMPLATE,
-        description="Prompt for an LLM to summarize a set of summaries of documents into one",
-    )
-    max_summarization_tokens: int = Field(
-        default=DEFAULT_MAX_SUMMARIZATION_TOKENS,
-        description="Max number of tokens for summarized documents",
-    )
-
-
 class RerankerMode(str, Enum):
     POINTWISE = "pointwise"
     LISTWISE = "listwise"
@@ -696,7 +43,7 @@ def _missing_(cls, value):
 
 class RerankerConfig(BaseModel):
     model: str = DEFAULT_RERANKING_MODEL
-    base_url: str = DEFAULT_LLM_ENDPOINT
+    base_url: Optional[str] = None
     filtering_threshold: float = 0.5
     num_docs_to_keep: Optional[int] = None
     mode: RerankerMode = Field(
@@ -714,144 +61,3 @@ class RerankerConfig(BaseModel):
     top_logprobs: int = DEFAULT_RERANKER_TOP_LOGPROBS  # Number of top log probabilities to include
     max_tokens: int = DEFAULT_RERANKER_MAX_TOKENS  # Maximum tokens to generate
     valid_class_tokens: List[str] = DEFAULT_VALID_CLASS_TOKENS  # Valid class tokens to look for in the response
-
-
-class MultiHopRetrieverConfig(BaseModel):
-    """Configuration for multi-hop retrieval"""
-
-    base_retriever_type: RetrieverType = Field(
-        default=RetrieverType.VECTOR_STORE,
-        description="Type of base retriever to use for multi-hop retrieval",
-    )
-    max_hops: int = Field(default=3, description="Maximum number of follow-up questions to generate", ge=1)
-    reformulation_template: str = Field(
-        default=DEFAULT_QUESTION_REFORMULATION_TEMPLATE,
-        description="Template for reformulating questions",
-    )
-    llm_config: LLMConfig = Field(
-        default_factory=LLMConfig,
-        description="LLM configuration to use for generating follow-up questions",
-    )
-
-
-class RAGPipelineModel(BaseModel):
-    documents: Optional[List[Any]] = Field(default=None, description="List of documents")
-
-    vector_store_config: VectorStoreConfig = Field(
-        default_factory=VectorStoreConfig, description="Vector store configuration"
-    )
-
-    llm: Optional[Any] = Field(default=None, description="Language model")
-    llm_model_name: str = Field(default=DEFAULT_LLM_MODEL, description="Language model name")
-    llm_provider: Optional[str] = Field(default=None, description="Language model provider")
-    vector_store: Optional[VectorStore] = Field(
-        default=None,
-        description="Vector store",
-    )
-    db_connection_string: Optional[str] = Field(default=None, description="Database connection string")
-    metadata_config: Optional[MetadataConfig] = Field(
-        default=None, description="Configuration for metadata to be used for retrieval"
-    )
-    table_name: str = Field(default=DEFAULT_TEST_TABLE_NAME, description="Table name")
-    embedding_model: Optional[Any] = Field(default=None, description="Embedding model")
-    rag_prompt_template: str = Field(default=DEFAULT_RAG_PROMPT_TEMPLATE, description="RAG prompt template")
-    retriever_prompt_template: Optional[Union[str, dict]] = Field(default=None, description="Retriever prompt template")
-    retriever_type: RetrieverType = Field(default=RetrieverType.VECTOR_STORE, description="Retriever type")
-    search_type: SearchType = Field(default=SearchType.SIMILARITY, description="Type of search to perform")
-    search_kwargs: SearchKwargs = Field(
-        default_factory=SearchKwargs,
-        description="Search configuration for the retriever",
-    )
-    summarization_config: Optional[SummarizationConfig] = Field(
-        default=None,
-        description="Configuration for summarizing retrieved documents as context",
-    )
-    # SQL retriever specific.
-    sql_retriever_config: Optional[SQLRetrieverConfig] = Field(
-        default=None,
-        description="Configuration for retrieving documents by generating SQL to filter by metadata & order by distance function",
-    )
-
-    # Multi retriever specific
-    multi_retriever_mode: MultiVectorRetrieverMode = Field(
-        default=MultiVectorRetrieverMode.BOTH, description="Multi retriever mode"
-    )
-    max_concurrency: int = Field(default=DEFAULT_MAX_CONCURRENCY, description="Maximum concurrency")
-    id_key: int = Field(default=DEFAULT_ID_KEY, description="ID key")
-    parent_store: Optional[Any] = Field(default=None, description="Parent store")
-    text_splitter: Optional[TextSplitter] = Field(default=None, description="Text splitter")
-    chunk_size: int = Field(default=DEFAULT_CHUNK_SIZE, description="Chunk size")
-    chunk_overlap: int = Field(default=DEFAULT_CHUNK_OVERLAP, description="Chunk overlap")
-
-    # Auto retriever specific
-    auto_retriever_filter_columns: Optional[List[str]] = Field(default=None, description="Filter columns")
-    cardinality_threshold: int = Field(default=DEFAULT_CARDINALITY_THRESHOLD, description="Cardinality threshold")
-    content_column_name: str = Field(
-        default=DEFAULT_CONTENT_COLUMN_NAME,
-        description="Content column name (the column we will get embeddings)",
-    )
-    dataset_description: str = Field(default=DEFAULT_DATASET_DESCRIPTION, description="Description of the dataset")
-    reranker: bool = Field(default=DEFAULT_RERANKER_FLAG, description="Whether to use reranker")
-    reranker_config: RerankerConfig = Field(default_factory=RerankerConfig, description="Reranker configuration")
-
-    multi_hop_config: Optional[MultiHopRetrieverConfig] = Field(
-        default=None,
-        description="Configuration for multi-hop retrieval. Required when retriever_type is MULTI_HOP.",
-    )
-
-    @field_validator("multi_hop_config")
-    @classmethod
-    def validate_multi_hop_config(cls, v: Optional[MultiHopRetrieverConfig], info):
-        """Validate that multi_hop_config is set when using multi-hop retrieval."""
-        values = info.data
-        if values.get("retriever_type") == RetrieverType.MULTI_HOP and v is None:
-            raise ValueError("multi_hop_config must be set when using multi-hop retrieval")
-        return v
-
-    class Config:
-        arbitrary_types_allowed = True
-        extra = "forbid"
-
-        json_schema_extra = {
-            "example": {
-                "retriever_type": RetrieverType.VECTOR_STORE.value,
-                "multi_retriever_mode": MultiVectorRetrieverMode.BOTH.value,
-                # add more examples here
-            }
-        }
-
-    @classmethod
-    def get_field_names(cls):
-        return list(cls.model_fields.keys())
-
-    @field_validator("search_kwargs")
-    @classmethod
-    def validate_search_kwargs(cls, v: SearchKwargs, info) -> SearchKwargs:
-        search_type = info.data.get("search_type", SearchType.SIMILARITY)
-
-        # Validate MMR-specific parameters
-        if search_type == SearchType.MMR:
-            if v.fetch_k is not None and v.fetch_k <= v.k:
-                raise ValueError("fetch_k must be greater than k")
-            if v.lambda_mult is not None and (v.lambda_mult < 0 or v.lambda_mult > 1):
-                raise ValueError("lambda_mult must be between 0 and 1")
-            if v.fetch_k is None and v.lambda_mult is not None:
-                raise ValueError("fetch_k is required when using lambda_mult with MMR search type")
-            if v.lambda_mult is None and v.fetch_k is not None:
-                raise ValueError("lambda_mult is required when using fetch_k with MMR search type")
-        elif search_type != SearchType.MMR:
-            if v.fetch_k is not None:
-                raise ValueError("fetch_k is only valid for MMR search type")
-            if v.lambda_mult is not None:
-                raise ValueError("lambda_mult is only valid for MMR search type")
-
-        # Validate similarity_score_threshold parameters
-        if search_type == SearchType.SIMILARITY_SCORE_THRESHOLD:
-            if v.score_threshold is not None and (v.score_threshold < 0 or v.score_threshold > 1):
-                raise ValueError("score_threshold must be between 0 and 1")
-            if v.score_threshold is None:
-                raise ValueError("score_threshold is required for similarity_score_threshold search type")
-        elif search_type != SearchType.SIMILARITY_SCORE_THRESHOLD and v.score_threshold is not None:
-            raise ValueError("score_threshold is only valid for similarity_score_threshold search type")
-
-        return v
diff --git a/mindsdb/integrations/utilities/rag/splitters/custom_splitters.py b/mindsdb/integrations/utilities/rag/splitters/custom_splitters.py
index 0d932f40f23..525bcafc99b 100644
--- a/mindsdb/integrations/utilities/rag/splitters/custom_splitters.py
+++ b/mindsdb/integrations/utilities/rag/splitters/custom_splitters.py
@@ -44,7 +44,7 @@ def split_text(self, text: str) -> List[str]:
         Split text into chunks
 
         Args:
-            text: Text to split
+            text (str): Text to split
 
         Returns:
             List of text chunks
diff --git a/mindsdb/integrations/utilities/rag/storage/__init__.py b/mindsdb/integrations/utilities/rag/storage/__init__.py
deleted file mode 100644
index 0a80c3fc8cb..00000000000
--- a/mindsdb/integrations/utilities/rag/storage/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Storage utilities for RAG pipeline"""
diff --git a/mindsdb/integrations/utilities/rag/storage/in_memory_byte_store.py b/mindsdb/integrations/utilities/rag/storage/in_memory_byte_store.py
deleted file mode 100644
index 825fd2f1a47..00000000000
--- a/mindsdb/integrations/utilities/rag/storage/in_memory_byte_store.py
+++ /dev/null
@@ -1,96 +0,0 @@
-"""Custom in-memory byte store implementation to replace langchain's InMemoryByteStore"""
-
-from typing import List, Tuple, Any, Dict
-
-
-class InMemoryByteStore:
-    """
-    Custom implementation of InMemoryByteStore to replace langchain's version.
-    Stores key-value pairs in memory using a dictionary.
-    """
-
-    def __init__(self):
-        """Initialize the in-memory store with an empty dictionary"""
-        self._store: Dict[str, Any] = {}
-
-    def mset(self, key_value_pairs: List[Tuple[str, Any]]) -> None:
-        """
-        Store multiple key-value pairs
-
-        Args:
-            key_value_pairs: List of (key, value) tuples to store
-        """
-        for key, value in key_value_pairs:
-            self._store[str(key)] = value
-
-    def mget(self, keys: List[str]) -> List[Any]:
-        """
-        Retrieve multiple values by keys
-
-        Args:
-            keys: List of keys to retrieve
-
-        Returns:
-            List of values corresponding to keys (None for missing keys)
-        """
-        return [self._store.get(str(key)) for key in keys]
-
-    def get(self, key: str, default: Any = None) -> Any:
-        """
-        Retrieve a single value by key
-
-        Args:
-            key: Key to retrieve
-            default: Default value to return if key is not found
-
-        Returns:
-            Value associated with key, or default if not found
-        """
-        return self._store.get(str(key), default)
-
-    def set(self, key: str, value: Any) -> None:
-        """
-        Store a single key-value pair
-
-        Args:
-            key: Key to store
-            value: Value to store
-        """
-        self._store[str(key)] = value
-
-    def delete(self, key: str) -> bool:
-        """
-        Delete a key-value pair
-
-        Args:
-            key: Key to delete
-
-        Returns:
-            True if key was found and deleted, False otherwise
-        """
-        key_str = str(key)
-        if key_str in self._store:
-            del self._store[key_str]
-            return True
-        return False
-
-    def clear(self) -> None:
-        """Clear all stored key-value pairs"""
-        self._store.clear()
-
-    def keys(self) -> List[str]:
-        """
-        Get all keys in the store
-
-        Returns:
-            List of all keys
-        """
-        return list(self._store.keys())
-
-    def __contains__(self, key: str) -> bool:
-        """Check if a key exists in the store"""
-        return str(key) in self._store
-
-    def __len__(self) -> int:
-        """Get the number of key-value pairs in the store"""
-        return len(self._store)
diff --git a/mindsdb/integrations/utilities/rag/utils.py b/mindsdb/integrations/utilities/rag/utils.py
deleted file mode 100644
index 7461eed1a05..00000000000
--- a/mindsdb/integrations/utilities/rag/utils.py
+++ /dev/null
@@ -1,50 +0,0 @@
-from typing import List, Any
-
-import pandas as pd
-from mindsdb.interfaces.knowledge_base.preprocessing.document_types import SimpleDocument
-
-
-def df_to_documents(df: pd.DataFrame, content_column_name: str) -> List[SimpleDocument]:
-    """
-    Given a dataframe, convert it to a list of documents.
-
-    :param df: pd.DataFrame
-    :param content_column_name: str
-
-    :return: List[SimpleDocument]
-    """
-    documents = []
-    for _, row in df.iterrows():
-        metadata = row.to_dict()
-        page_content = metadata.pop(content_column_name)
-        documents.append(SimpleDocument(page_content=page_content, metadata=metadata))
-    return documents
-
-
-def documents_to_df(
-    content_column_name: str, documents: List[Any], embedding_model: Any = None, with_embeddings: bool = False
-) -> pd.DataFrame:
-    """
-    Given a list of documents, convert it to a dataframe.
-
-    :param content_column_name: str
-    :param documents: List of document-like objects with page_content and metadata attributes
-    :param embedding_model: Embedding model with embed_documents method
-    :param with_embeddings: bool
-
-    :return: pd.DataFrame
-    """
-    df = pd.DataFrame([doc.metadata for doc in documents])
-
-    df[content_column_name] = [doc.page_content for doc in documents]
-
-    if "date" in df.columns:
-        df["date"] = pd.to_datetime(df["date"], errors="coerce")
-
-    # Reordering the columns to have the content column first.
-    df = df[[content_column_name] + [col for col in df.columns if col != content_column_name]]
-
-    if with_embeddings and embedding_model is not None:
-        df["embeddings"] = embedding_model.embed_documents(df[content_column_name].tolist())
-
-    return df
diff --git a/mindsdb/integrations/utilities/rag/vector_store.py b/mindsdb/integrations/utilities/rag/vector_store.py
deleted file mode 100644
index 69f860d29b1..00000000000
--- a/mindsdb/integrations/utilities/rag/vector_store.py
+++ /dev/null
@@ -1,93 +0,0 @@
-import time
-from datetime import timedelta
-from typing import List, Any, Optional
-
-from mindsdb.integrations.utilities.rag.loaders.vector_store_loader.base_vector_store import VectorStore
-from mindsdb.integrations.utilities.rag.loaders.vector_store_loader.vector_store_loader import VectorStoreLoader
-from mindsdb.integrations.utilities.rag.settings import VectorStoreConfig, SearchKwargs
-
-# gpt-3.5-turbo
-_DEFAULT_TPM_LIMIT = 60000
-_DEFAULT_RATE_LIMIT_INTERVAL = timedelta(seconds=10)
-_INITIAL_TOKEN_USAGE = 0
-
-
-class VectorStoreOperator:
-    """
-    Encapsulates the logic for adding documents to a vector store with rate limiting.
-    """
-
-    def __init__(
-        self,
-        vector_store: VectorStore,
-        embedding_model: Any,
-        documents: Optional[List[Any]] = None,
-        vector_store_config: VectorStoreConfig = None,
-        token_per_minute_limit: int = _DEFAULT_TPM_LIMIT,
-        rate_limit_interval: timedelta = _DEFAULT_RATE_LIMIT_INTERVAL,
-        search_kwargs: SearchKwargs = None,
-    ):
-        self.documents = documents
-        self.embedding_model = embedding_model
-        self.token_per_minute_limit = token_per_minute_limit
-        self.rate_limit_interval = rate_limit_interval
-        self.current_token_usage = _INITIAL_TOKEN_USAGE
-        self._vector_store = None
-        self.vector_store_config = vector_store_config
-        self.search_kwargs = search_kwargs or SearchKwargs()
-
-        self.verify_vector_store(vector_store, documents)
-
-    def verify_vector_store(self, vector_store, documents):
-        if documents:
-            self._add_documents_to_store(documents, vector_store)
-        elif isinstance(vector_store, VectorStore):
-            # checking is it instance or subclass instance
-            self._vector_store = vector_store
-        elif issubclass(vector_store, VectorStore):
-            # if it is subclass instance, then create instance of it using vector_store_config
-            self._vector_store = load_vector_store(self.embedding_model, self.vector_store_config)
-
-    @property
-    def vector_store(self):
-        return self._vector_store
-
-    @staticmethod
-    def _calculate_token_usage(document):
-        return len(document.page_content)
-
-    def _rate_limit(self):
-        if self.current_token_usage >= self.token_per_minute_limit:
-            time.sleep(self.rate_limit_interval.total_seconds())
-            self.current_token_usage = _INITIAL_TOKEN_USAGE
-
-    def _update_token_usage(self, document: Any):
-        self._rate_limit()
-        self.current_token_usage += self._calculate_token_usage(document)
-
-    def _add_document(self, document: Any):
-        self._update_token_usage(document)
-        self.vector_store.add_documents([document])
-
-    def _add_documents_to_store(self, documents: List[Any], vector_store: VectorStore):
-        self._init_vector_store(documents, vector_store)
-        self.add_documents(documents)
-
-    def _init_vector_store(self, documents: List[Any], vector_store: VectorStore):
-        if len(documents) > 0:
-            self._vector_store = vector_store.from_documents(documents=[documents[0]], embedding=self.embedding_model)
-
-    def add_documents(self, documents: List[Any]):
-        for document in documents:
-            self._add_document(document)
-
-
-def load_vector_store(embedding_model: Any, config: VectorStoreConfig) -> VectorStore:
-    """
-    Loads the vector store based on the provided config and embeddings model
-    :param embedding_model:
-    :param config:
-    :return:
-    """
-    loader = VectorStoreLoader(embedding_model=embedding_model, config=config)
-    return loader.load()
diff --git a/mindsdb/integrations/utilities/sql_utils.py b/mindsdb/integrations/utilities/sql_utils.py
index 1d796f49b02..e123b9ed837 100644
--- a/mindsdb/integrations/utilities/sql_utils.py
+++ b/mindsdb/integrations/utilities/sql_utils.py
@@ -458,7 +458,10 @@ def filter_dataframe(df: pd.DataFrame, conditions: list, raw_conditions=None, or
                 else:
                     item = ast.BinaryOperation(op=op, args=[arg1_identifier, ast.Constant(arg2)])
             else:
-                item = ast.BinaryOperation(op=op, args=[arg1_identifier, ast.Constant(arg2)])
+                if isinstance(arg2, ASTNode):
+                    item = ast.BinaryOperation(op=op, args=[arg1_identifier, arg2])
+                else:
+                    item = ast.BinaryOperation(op=op, args=[arg1_identifier, ast.Constant(arg2)])
 
         if where_query is None:
             where_query = item
diff --git a/mindsdb/interfaces/agents/agents_controller.py b/mindsdb/interfaces/agents/agents_controller.py
index 90e809ab568..504c2891af6 100644
--- a/mindsdb/interfaces/agents/agents_controller.py
+++ b/mindsdb/interfaces/agents/agents_controller.py
@@ -1,7 +1,9 @@
 import datetime
-from typing import Dict, Iterator, List, Union, Tuple, Optional, Any
+from typing import Dict, Iterator, List, Union, Tuple, Optional, Any, Text
 import copy
 
+from enum import Enum
+from pydantic import BaseModel
 from sqlalchemy.orm.attributes import flag_modified
 from sqlalchemy import null
 import pandas as pd
@@ -13,19 +15,58 @@
 from mindsdb.interfaces.model.functions import PredictorRecordNotFound
 from mindsdb.interfaces.model.model_controller import ModelController
 from mindsdb.utilities.config import config
+from mindsdb.utilities.utils import validate_pydantic_params
 from mindsdb.utilities import log
+from mindsdb.interfaces.agents.utils.sql_toolkit import MindsDBQuery
 
 from mindsdb.utilities.exception import EntityExistsError, EntityNotExistsError
 
 from .utils.constants import ASSISTANT_COLUMN, SUPPORTED_PROVIDERS, PROVIDER_TO_MODELS
 from .utils.pydantic_ai_model_factory import get_llm_provider
-
+from .pydantic_ai_agent import check_agent_llm
 
 logger = log.getLogger(__name__)
 
 default_project = config.get("default_project")
 
 
+def check_agent_data(data):
+    tables = data.get("tables", [])
+    knowledge_bases = data.get("knowledge_bases", [])
+    if tables or knowledge_bases:
+        sql_toolkit = MindsDBQuery(tables=tables, knowledge_bases=knowledge_bases)
+
+        if tables and len(sql_toolkit.get_usable_table_names(lazy=False)) == 0:
+            raise ValueError(f"No tables found: {tables}")
+
+        if knowledge_bases and len(sql_toolkit.get_usable_knowledge_base_names(lazy=False)) == 0:
+            raise ValueError(f"No knowledge bases found: {knowledge_bases}")
+
+
+class AgentParamsData(BaseModel):
+    knowledge_bases: List[str] | None = None
+    tables: List[str] | None = None
+
+    class Config:
+        extra = "forbid"
+
+
+class AgentMode(Enum):
+    TEXT = "text"
+    SQL = "sql"
+
+
+class AgentParams(BaseModel):
+    prompt_template: str | None = None
+    model: Dict[Text, Any] | None = None
+    data: AgentParamsData | None = None
+    timeout: int | None = None
+    mode: AgentMode = AgentMode.TEXT
+
+    class Config:
+        extra = "forbid"
+
+
 class AgentsController:
     """Handles CRUD operations at the database level for Agents"""
 
@@ -149,8 +190,7 @@ def add_agent(
         self,
         name: str,
         project_name: str = None,
-        model_name: Union[str, dict] = None,
-        provider: str = None,
+        model: dict = None,
         params: Dict[str, Any] = None,
     ) -> db.Agents:
         """
@@ -159,25 +199,16 @@ def add_agent(
         Parameters:
             name (str): The name of the new agent
             project_name (str): The containing project
-            model_name (str | dict): The name of the existing ML model the agent will use
-            provider (str): The provider of the model
+            model: Dict, parameters for the model to use
+                - provider: The provider of the model (e.g., 'openai', 'google')
+                - Other model-specific parameters like 'api_key', 'model_name', etc.
+
             params (Dict[str, str]): Parameters to use when running the agent
                 data: Dict, data sources for an agent, keys:
                   - knowledge_bases: List of KBs to use
                   - tables: list of tables to use
-                model: Dict, parameters for the model to use
-                  - provider: The provider of the model (e.g., 'openai', 'google')
-                  - Other model-specific parameters like 'api_key', 'model_name', etc.
                 <provider>_api_key: API key for the provider (e.g., openai_api_key)
 
-                # Deprecated parameters:
-                database: The database to use (default is 'mindsdb')
-                knowledge_base_database: The database to use for knowledge base queries (default is 'mindsdb')
-                include_tables: List of tables to include
-                ignore_tables: List of tables to ignore
-                include_knowledge_bases: List of knowledge bases to include
-                ignore_knowledge_bases: List of knowledge bases to ignore
-
         Returns:
             agent (db.Agents): The created agent
 
@@ -195,61 +226,19 @@ def add_agent(
 
         # No need to copy params since we're not preserving the original reference
         params = params or {}
+        params["model"] = model
 
-        if isinstance(model_name, dict):
-            # move into params
-            params["model"] = model_name
-            model_name = None
+        # check agent params
+        validate_pydantic_params(params, AgentParams, "agent")
 
-        if model_name is not None:
-            _, provider = self.check_model_provider(model_name, provider)
+        # check llm works
+        llm_params = self.get_agent_llm_params(model)
+        check_agent_llm(llm_params)
 
-        if model_name is None:
-            logger.warning("'model_name' param is not provided. Using default global llm model at runtime.")
-
-        # If model_name is not provided, we use default global llm model at runtime
-        # Default parameters will be applied at runtime via get_agent_llm_params
-        # This allows global default updates to apply to all agents immediately
-
-        # Extract API key if provided in the format <provider>_api_key
-        if provider is not None:
-            provider_api_key_param = f"{provider.lower()}_api_key"
-            if provider_api_key_param in params:
-                # Keep the API key in params for the agent to use
-                # It will be picked up by get_api_key() in handler_utils.py
-                pass
-
-        # Handle generic api_key parameter if provided
-        if "api_key" in params:
-            # Keep the generic API key in params for the agent to use
-            # It will be picked up by get_api_key() in handler_utils.py
-            pass
-
-        depreciated_params = [
-            "database",
-            "knowledge_base_database",
-            "include_tables",
-            "ignore_tables",
-            "include_knowledge_bases",
-            "ignore_knowledge_bases",
-        ]
-        if any(param in params for param in depreciated_params):
-            raise ValueError(
-                f"Parameters {', '.join(depreciated_params)} are deprecated. "
-                "Use 'data' parameter with 'tables' and 'knowledge_bases' keys instead."
-            )
-
-        include_tables = None
-        include_knowledge_bases = None
-        if "data" in params:
-            include_knowledge_bases = params["data"].get("knowledge_bases")
-            include_tables = params["data"].get("tables")
-
-        # Convert string parameters to lists if needed
-        if isinstance(include_tables, str):
-            include_tables = [t.strip() for t in include_tables.split(",")]
-        if isinstance(include_knowledge_bases, str):
-            include_knowledge_bases = [kb.strip() for kb in include_knowledge_bases.split(",")]
+        # check data
+        data = params.get("data", {})
+        if data:
+            check_agent_data(data)
 
         agent = db.Agents(
             name=name,
@@ -257,8 +246,6 @@ def add_agent(
             company_id=ctx.company_id,
             user_id=ctx.user_id,
             user_class=ctx.user_class,
-            model_name=model_name,
-            provider=provider,
             params=params,
         )
 
@@ -272,9 +259,8 @@ def update_agent(
         agent_name: str,
         project_name: str = default_project,
         name: str = None,
-        model_name: Union[str, dict] = None,
-        provider: str = None,
-        params: Dict[str, str] = None,
+        model: dict = None,
+        params: Dict[str, Any] = None,
     ):
         """
         Updates an agent in the database.
@@ -283,8 +269,7 @@ def update_agent(
             agent_name (str): The name of the new agent, or existing agent to update
             project_name (str): The containing project
             name (str): The updated name of the agent
-            model_name (str | dict): The name of the existing ML model the agent will use
-            provider (str): The provider of the model
+            model dict: model parameters
             params: (Dict[str, str]): Parameters to use when running the agent
 
         Returns:
@@ -301,12 +286,7 @@ def update_agent(
         existing_params = existing_agent.params or {}
 
         is_demo = (existing_agent.params or {}).get("is_demo", False)
-        if is_demo and (
-            (name is not None and name != agent_name)
-            or (model_name is not None and existing_agent.model_name != model_name)
-            or (provider is not None and existing_agent.provider != provider)
-            or (isinstance(params, dict) and len(params) > 0 and "prompt_template" not in params)
-        ):
+        if is_demo:
             raise ValueError("It is forbidden to change properties of the demo object")
 
         if name is not None and name != agent_name:
@@ -316,27 +296,34 @@ def update_agent(
                 raise EntityExistsError(f"Agent with updated name already exists: {name}")
             existing_agent.name = name
 
-        if model_name or provider:
-            if isinstance(model_name, dict):
-                # move into params
-                existing_params["model"] = model_name
-                model_name = None
-
-            # check model and provider
-            _, provider = self.check_model_provider(model_name, provider)
-            # Update model and provider
-            existing_agent.model_name = model_name
-            existing_agent.provider = provider
-
-        if params is not None:
-            # Merge params on update
-            existing_params.update(params)
-            # Remove None values entirely.
-            params = {k: v for k, v in existing_params.items() if v is not None}
-            existing_agent.params = params
-            # Some versions of SQL Alchemy won't handle JSON updates correctly without this.
-            # See: https://docs.sqlalchemy.org/en/20/orm/session_api.html#sqlalchemy.orm.attributes.flag_modified
-            flag_modified(existing_agent, "params")
+        params = params or {}
+
+        if model:
+            params["model"] = model
+
+        if params:
+            validate_pydantic_params(params, AgentParams, "agent")
+        else:
+            # do nothing
+            return existing_agent
+
+        if model:
+            # check llm works
+            llm_params = self.get_agent_llm_params(model)
+            check_agent_llm(llm_params)
+
+        data = params.get("data", {})
+        if data:
+            check_agent_data(data)
+
+        # Merge params on update
+        existing_params.update(params)
+        # Remove None values entirely.
+        params = {k: v for k, v in existing_params.items() if v is not None}
+        existing_agent.params = params
+        # Some versions of SQL Alchemy won't handle JSON updates correctly without this.
+        # See: https://docs.sqlalchemy.org/en/20/orm/session_api.html#sqlalchemy.orm.attributes.flag_modified
+        flag_modified(existing_agent, "params")
         db.session.commit()
 
         return existing_agent
@@ -362,32 +349,12 @@ def delete_agent(self, agent_name: str, project_name: str = default_project):
         agent.deleted_at = datetime.datetime.now()
         db.session.commit()
 
-    def get_agent_llm_params(self, agent):
+    def get_agent_llm_params(self, model_params):
         """
         Get agent LLM parameters by combining default config with user provided parameters.
         Uses the same pattern as knowledge bases get_model_params function.
         """
 
-        agent_params = agent.params
-
-        # Get model params from agent params (same structure as knowledge bases)
-        if "model" in agent_params:
-            model_params = agent_params.get("model", {})
-            if not isinstance(model_params, dict):
-                raise ValueError("Model parameters must be passed as a JSON object")
-        else:
-            # params for LLM can be arbitrary (backward compatibility)
-            model_params = copy.deepcopy(agent_params)
-            model_params.pop("mode", None)
-            model_params.pop("prompt_template", None)
-
-            _, provider = self.check_model_provider(agent.model_name, agent.provider)
-
-            if agent.model_name is not None:
-                model_params["model_name"] = agent.model_name
-            if provider is not None:
-                model_params["provider"] = provider
-
         combined_model_params = copy.deepcopy(config.get("default_llm", {}))
 
         if model_params:
@@ -433,7 +400,7 @@ def get_completion(
         from .pydantic_ai_agent import PydanticAIAgent
 
         # Get agent parameters and combine with default LLM parameters at runtime
-        llm_params = self.get_agent_llm_params(agent)
+        llm_params = self.get_agent_llm_params(agent.params.get("model"))
 
         pydantic_agent = PydanticAIAgent(agent, llm_params=llm_params)
 
diff --git a/mindsdb/interfaces/agents/callback_handlers.py b/mindsdb/interfaces/agents/callback_handlers.py
deleted file mode 100644
index f4735b737c7..00000000000
--- a/mindsdb/interfaces/agents/callback_handlers.py
+++ /dev/null
@@ -1,177 +0,0 @@
-import io
-import logging
-import contextlib
-from typing import Any, Dict, List, Union, Callable
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.callbacks.base import BaseCallbackHandler
-from langchain_core.messages.base import BaseMessage
-from langchain_core.outputs import LLMResult
-from langchain_core.callbacks import StdOutCallbackHandler
-
-
-class ContextCaptureCallback(BaseCallbackHandler):
-    def __init__(self):
-        self.context = None
-
-    def on_retriever_end(self, documents: List[Any], *, run_id: str, parent_run_id: Union[str, None] = None, **kwargs: Any) -> Any:
-        self.context = [{
-            'page_content': doc.page_content,
-            'metadata': doc.metadata
-        } for doc in documents]
-
-    def get_contexts(self):
-        return self.context
-
-
-class VerboseLogCallbackHandler(StdOutCallbackHandler):
-    def __init__(self, logger: logging.Logger, verbose: bool):
-        self.logger = logger
-        self.verbose = verbose
-        super().__init__()
-
-    def __call(self, method: Callable, *args: List[Any], **kwargs: Any) -> Any:
-        if self.verbose is False:
-            return
-        f = io.StringIO()
-        with contextlib.redirect_stdout(f):
-            method(*args, **kwargs)
-        output = f.getvalue()
-        self.logger.info(output)
-
-    def on_chain_start(self, *args: List[Any], **kwargs: Any) -> None:
-        self.__call(super().on_chain_start, *args, **kwargs)
-
-    def on_chain_end(self, *args: List[Any], **kwargs: Any) -> None:
-        self.__call(super().on_chain_end, *args, **kwargs)
-
-    def on_agent_action(self, *args: List[Any], **kwargs: Any) -> None:
-        self.__call(super().on_agent_action, *args, **kwargs)
-
-    def on_tool_end(self, *args: List[Any], **kwargs: Any) -> None:
-        self.__call(super().on_tool_end, *args, **kwargs)
-
-    def on_text(self, *args: List[Any], **kwargs: Any) -> None:
-        self.__call(super().on_text, *args, **kwargs)
-
-    def on_agent_finish(self, *args: List[Any], **kwargs: Any) -> None:
-        self.__call(super().on_agent_finish, *args, **kwargs)
-
-
-class LogCallbackHandler(BaseCallbackHandler):
-    '''Langchain callback handler that logs agent and chain executions.'''
-
-    def __init__(self, logger: logging.Logger, verbose: bool = True):
-        logger.setLevel('DEBUG')
-        self.logger = logger
-        self._num_running_chains = 0
-        self.generated_sql = None
-        self.verbose_log_handler = VerboseLogCallbackHandler(logger, verbose)
-
-    def on_llm_start(
-        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
-    ) -> Any:
-        '''Run when LLM starts running.'''
-        self.logger.debug('LLM started with prompts:')
-        for prompt in prompts:
-            self.logger.debug(prompt[:50])
-        self.verbose_log_handler.on_llm_start(serialized, prompts, **kwargs)
-
-    def on_chat_model_start(
-            self,
-            serialized: Dict[str, Any],
-            messages: List[List[BaseMessage]], **kwargs: Any
-    ) -> Any:
-        '''Run when Chat Model starts running.'''
-        self.logger.debug('Chat model started with messages:')
-        for message_list in messages:
-            for message in message_list:
-                self.logger.debug(message.pretty_repr())
-
-    def on_llm_new_token(self, token: str, **kwargs: Any) -> Any:
-        '''Run on new LLM token. Only available when streaming is enabled.'''
-        pass
-
-    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> Any:
-        '''Run when LLM ends running.'''
-        self.logger.debug('LLM ended with response:')
-        self.logger.debug(str(response.llm_output))
-
-    def on_llm_error(
-        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
-    ) -> Any:
-        '''Run when LLM errors.'''
-        self.logger.debug(f'LLM encountered an error: {str(error)}')
-
-    def on_chain_start(
-        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
-    ) -> Any:
-        '''Run when chain starts running.'''
-        self._num_running_chains += 1
-        self.logger.info('Entering new LLM chain ({} total)'.format(
-            self._num_running_chains))
-        self.logger.debug('Inputs: {}'.format(inputs))
-
-        self.verbose_log_handler.on_chain_start(serialized=serialized, inputs=inputs, **kwargs)
-
-    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> Any:
-        '''Run when chain ends running.'''
-        self._num_running_chains -= 1
-        self.logger.info('Ended LLM chain ({} total)'.format(
-            self._num_running_chains))
-        self.logger.debug('Outputs: {}'.format(outputs))
-
-        self.verbose_log_handler.on_chain_end(outputs=outputs, **kwargs)
-
-    def on_chain_error(
-        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
-    ) -> Any:
-        '''Run when chain errors.'''
-        self._num_running_chains -= 1
-        self.logger.error(
-            'LLM chain encountered an error ({} running): {}'.format(
-                self._num_running_chains, error))
-
-    def on_tool_start(
-        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
-    ) -> Any:
-        '''Run when tool starts running.'''
-        pass
-
-    def on_tool_end(self, output: str, **kwargs: Any) -> Any:
-        '''Run when tool ends running.'''
-        self.verbose_log_handler.on_tool_end(output=output, **kwargs)
-
-    def on_tool_error(
-        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
-    ) -> Any:
-        '''Run when tool errors.'''
-        pass
-
-    def on_text(self, text: str, **kwargs: Any) -> Any:
-        '''Run on arbitrary text.'''
-        self.verbose_log_handler.on_text(text=text, **kwargs)
-
-    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
-        '''Run on agent action.'''
-        self.logger.debug(f'Running tool {action.tool} with input:')
-        self.logger.debug(action.tool_input)
-
-        stop_block = 'Observation: '
-        if stop_block in action.tool_input:
-            action.tool_input = action.tool_input[: action.tool_input.find(stop_block)]
-
-        if action.tool.startswith("sql_db_query"):
-            # Save the generated SQL query
-            self.generated_sql = action.tool_input
-
-        # fix for mistral
-        action.tool = action.tool.replace('\\', '')
-
-        self.verbose_log_handler.on_agent_action(action=action, **kwargs)
-
-    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> Any:
-        '''Run on agent end.'''
-        self.logger.debug('Agent finished with return values:')
-        self.logger.debug(str(finish.return_values))
-        self.verbose_log_handler.on_agent_finish(finish=finish, **kwargs)
diff --git a/mindsdb/interfaces/agents/event_dispatch_callback_handler.py b/mindsdb/interfaces/agents/event_dispatch_callback_handler.py
deleted file mode 100644
index 7446ba2adaa..00000000000
--- a/mindsdb/interfaces/agents/event_dispatch_callback_handler.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import queue
-from typing import Any, Dict, List, Optional, Sequence
-from uuid import UUID
-
-from langchain_core.callbacks import BaseCallbackHandler
-from langchain_core.documents import Document
-
-
-class EventDispatchCallbackHandler(BaseCallbackHandler):
-    '''Puts dispatched events onto an event queue to be processed as a streaming chunk'''
-    def __init__(self, queue: queue.Queue):
-        self.queue = queue
-
-    def on_custom_event(
-        self,
-        name: str,
-        data: Any,
-        *,
-        run_id: UUID,
-        tags: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-        **kwargs
-    ):
-        self.queue.put({
-            'type': 'event',
-            'name': name,
-            'data': data
-        })
-
-    def on_retriever_end(
-        self,
-        documents: Sequence[Document],
-        *,
-        run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        **kwargs: Any,
-    ) -> Any:
-        document_objects = []
-        for d in documents:
-            document_objects.append({
-                'content': d.page_content,
-                'metadata': d.metadata
-            })
-        self.queue.put({
-            'type': 'event',
-            'name': 'retriever_end',
-            'data': {
-                'documents': document_objects
-            }
-        })
diff --git a/mindsdb/interfaces/agents/langfuse_callback_handler.py b/mindsdb/interfaces/agents/langfuse_callback_handler.py
deleted file mode 100644
index 948eadda6b8..00000000000
--- a/mindsdb/interfaces/agents/langfuse_callback_handler.py
+++ /dev/null
@@ -1,308 +0,0 @@
-from typing import Any, Dict, Union, Optional, List
-from uuid import uuid4
-import datetime
-import json
-
-from langchain_core.callbacks.base import BaseCallbackHandler
-
-from mindsdb.utilities import log
-from mindsdb.interfaces.storage import db
-
-logger = log.getLogger(__name__)
-logger.setLevel('DEBUG')
-
-
-class LangfuseCallbackHandler(BaseCallbackHandler):
-    """Langchain callback handler that traces tool & chain executions using Langfuse."""
-
-    def __init__(self, langfuse, trace_id: Optional[str] = None, observation_id: Optional[str] = None):
-        self.langfuse = langfuse
-        self.chain_uuid_to_span = {}
-        self.action_uuid_to_span = {}
-        # if these are not available, we generate some UUIDs
-        self.trace_id = trace_id or uuid4().hex
-        self.observation_id = observation_id or uuid4().hex
-        # Track metrics about tools and chains
-        self.tool_metrics = {}
-        self.chain_metrics = {}
-        self.current_chain = None
-
-    def on_tool_start(
-            self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
-    ) -> Any:
-        """Run when tool starts running."""
-        parent_run_uuid = kwargs.get('parent_run_id', uuid4()).hex
-        action_span = self.action_uuid_to_span.get(parent_run_uuid)
-        if action_span is None:
-            return
-
-        tool_name = serialized.get("name", "tool")
-        start_time = datetime.datetime.now()
-
-        # Initialize or update tool metrics
-        if tool_name not in self.tool_metrics:
-            self.tool_metrics[tool_name] = {
-                'count': 0,
-                'total_time': 0,
-                'errors': 0,
-                'last_error': None,
-                'inputs': []
-            }
-
-        self.tool_metrics[tool_name]['count'] += 1
-        self.tool_metrics[tool_name]['inputs'].append(input_str)
-
-        metadata = {
-            'tool_name': tool_name,
-            'started': start_time.isoformat(),
-            'start_timestamp': start_time.timestamp(),
-            'input_length': len(input_str) if input_str else 0
-        }
-        action_span.update(metadata=metadata)
-
-    def on_tool_end(self, output: str, **kwargs: Any) -> Any:
-        """Run when tool ends running."""
-        parent_run_uuid = kwargs.get('parent_run_id', uuid4()).hex
-        action_span = self.action_uuid_to_span.get(parent_run_uuid)
-        if action_span is None:
-            return
-
-        end_time = datetime.datetime.now()
-        tool_name = action_span.metadata.get('tool_name', 'unknown')
-        start_timestamp = action_span.metadata.get('start_timestamp')
-
-        if start_timestamp:
-            duration = end_time.timestamp() - start_timestamp
-            if tool_name in self.tool_metrics:
-                self.tool_metrics[tool_name]['total_time'] += duration
-
-        metadata = {
-            'finished': end_time.isoformat(),
-            'duration_seconds': duration if start_timestamp else None,
-            'output_length': len(output) if output else 0
-        }
-
-        action_span.update(
-            output=output,  # tool output is action output (unless superseded by a global action output)
-            metadata=metadata
-        )
-
-    def on_tool_error(
-            self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
-    ) -> Any:
-        """Run when tool errors."""
-        parent_run_uuid = kwargs.get('parent_run_id', uuid4()).hex
-        action_span = self.action_uuid_to_span.get(parent_run_uuid)
-        if action_span is None:
-            return
-
-        try:
-            error_str = str(error)
-        except Exception:
-            error_str = "Couldn't get error string."
-
-        tool_name = action_span.metadata.get('tool_name', 'unknown')
-        if tool_name in self.tool_metrics:
-            self.tool_metrics[tool_name]['errors'] += 1
-            self.tool_metrics[tool_name]['last_error'] = error_str
-
-        metadata = {
-            'error_description': error_str,
-            'error_type': error.__class__.__name__,
-            'error_time': datetime.datetime.now().isoformat()
-        }
-        action_span.update(metadata=metadata)
-
-    def on_chain_start(
-            self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
-    ) -> Any:
-        """Run when chain starts running."""
-        if self.langfuse is None:
-            return
-
-        run_uuid = kwargs.get('run_id', uuid4()).hex
-
-        if serialized is None:
-            serialized = {}
-
-        chain_name = serialized.get("name", "chain")
-        start_time = datetime.datetime.now()
-
-        # Initialize or update chain metrics
-        if chain_name not in self.chain_metrics:
-            self.chain_metrics[chain_name] = {
-                'count': 0,
-                'total_time': 0,
-                'errors': 0,
-                'last_error': None
-            }
-
-        self.chain_metrics[chain_name]['count'] += 1
-        self.current_chain = chain_name
-
-        try:
-            chain_span = self.langfuse.span(
-                name=f'{chain_name}-{run_uuid}',
-                trace_id=self.trace_id,
-                parent_observation_id=self.observation_id,
-                input=json.dumps(inputs, indent=2)
-            )
-
-            metadata = {
-                'chain_name': chain_name,
-                'started': start_time.isoformat(),
-                'start_timestamp': start_time.timestamp(),
-                'input_keys': list(inputs.keys()) if isinstance(inputs, dict) else None,
-                'input_size': len(inputs) if isinstance(inputs, dict) else len(str(inputs))
-            }
-            chain_span.update(metadata=metadata)
-            self.chain_uuid_to_span[run_uuid] = chain_span
-        except Exception as e:
-            logger.warning(f"Error creating Langfuse span: {str(e)}")
-
-    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> Any:
-        """Run when chain ends running."""
-        if self.langfuse is None:
-            return
-
-        chain_uuid = kwargs.get('run_id', uuid4()).hex
-        if chain_uuid not in self.chain_uuid_to_span:
-            return
-        chain_span = self.chain_uuid_to_span.pop(chain_uuid)
-        if chain_span is None:
-            return
-
-        try:
-            end_time = datetime.datetime.now()
-            chain_name = chain_span.metadata.get('chain_name', 'unknown')
-            start_timestamp = chain_span.metadata.get('start_timestamp')
-
-            if start_timestamp and chain_name in self.chain_metrics:
-                duration = end_time.timestamp() - start_timestamp
-                self.chain_metrics[chain_name]['total_time'] += duration
-
-            metadata = {
-                'finished': end_time.isoformat(),
-                'duration_seconds': duration if start_timestamp else None,
-                'output_keys': list(outputs.keys()) if isinstance(outputs, dict) else None,
-                'output_size': len(outputs) if isinstance(outputs, dict) else len(str(outputs))
-            }
-            chain_span.update(output=json.dumps(outputs, indent=2), metadata=metadata)
-            chain_span.end()
-        except Exception as e:
-            logger.warning(f"Error updating Langfuse span: {str(e)}")
-
-    def on_chain_error(self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any) -> Any:
-        """Run when chain errors."""
-        chain_uuid = kwargs.get('run_id', uuid4()).hex
-        if chain_uuid not in self.chain_uuid_to_span:
-            return
-        chain_span = self.chain_uuid_to_span.get(chain_uuid)
-        if chain_span is None:
-            return
-
-        try:
-            error_str = str(error)
-        except Exception:
-            error_str = "Couldn't get error string."
-
-        chain_name = chain_span.metadata.get('chain_name', 'unknown')
-        if chain_name in self.chain_metrics:
-            self.chain_metrics[chain_name]['errors'] += 1
-            self.chain_metrics[chain_name]['last_error'] = error_str
-
-        metadata = {
-            'error_description': error_str,
-            'error_type': error.__class__.__name__,
-            'error_time': datetime.datetime.now().isoformat()
-        }
-        chain_span.update(metadata=metadata)
-
-    def on_agent_action(self, action, **kwargs: Any) -> Any:
-        """Run on agent action."""
-        if self.langfuse is None:
-            return
-
-        run_uuid = kwargs.get('run_id', uuid4()).hex
-        try:
-            action_span = self.langfuse.span(
-                name=f'{getattr(action, "type", "action")}-{getattr(action, "tool", "")}-{run_uuid}',
-                trace_id=self.trace_id,
-                parent_observation_id=self.observation_id,
-                input=str(action)
-            )
-            self.action_uuid_to_span[run_uuid] = action_span
-        except Exception as e:
-            logger.warning(f"Error creating Langfuse span for agent action: {str(e)}")
-
-    def on_agent_finish(self, finish, **kwargs: Any) -> Any:
-        """Run on agent end."""
-        if self.langfuse is None:
-            return
-
-        run_uuid = kwargs.get('run_id', uuid4()).hex
-        if run_uuid not in self.action_uuid_to_span:
-            return
-        action_span = self.action_uuid_to_span.pop(run_uuid)
-        if action_span is None:
-            return
-
-        try:
-            if finish is not None:
-                action_span.update(output=finish)  # supersedes tool output
-            action_span.end()
-        except Exception as e:
-            logger.warning(f"Error updating Langfuse span: {str(e)}")
-
-    def auth_check(self):
-        if self.langfuse is not None:
-            return self.langfuse.auth_check()
-        return False
-
-    def get_metrics(self) -> Dict[str, Any]:
-        """Get collected metrics about tools and chains.
-
-        Returns:
-            Dict containing:
-            - tool_metrics: Statistics about tool usage, errors, and timing
-            - chain_metrics: Statistics about chain execution, errors, and timing
-            For each tool/chain, includes:
-                - count: Number of times used
-                - total_time: Total execution time
-                - errors: Number of errors
-                - last_error: Most recent error message
-                - avg_duration: Average execution time
-        """
-        metrics = {
-            'tool_metrics': {},
-            'chain_metrics': {}
-        }
-
-        # Process tool metrics
-        for tool_name, data in self.tool_metrics.items():
-            metrics['tool_metrics'][tool_name] = {
-                'count': data['count'],
-                'total_time': data['total_time'],
-                'avg_duration': data['total_time'] / data['count'] if data['count'] > 0 else 0,
-                'errors': data['errors'],
-                'last_error': data['last_error'],
-                'error_rate': data['errors'] / data['count'] if data['count'] > 0 else 0
-            }
-
-        # Process chain metrics
-        for chain_name, data in self.chain_metrics.items():
-            metrics['chain_metrics'][chain_name] = {
-                'count': data['count'],
-                'total_time': data['total_time'],
-                'avg_duration': data['total_time'] / data['count'] if data['count'] > 0 else 0,
-                'errors': data['errors'],
-                'last_error': data['last_error'],
-                'error_rate': data['errors'] / data['count'] if data['count'] > 0 else 0
-            }
-
-        return metrics
-
-
-def get_skills(agent: db.Agents) -> List:
-    """ Retrieve skills from agent `skills` attribute. Specific to agent endpoints. """
-    return [rel.skill.type for rel in agent.skills_relationships]
diff --git a/mindsdb/interfaces/agents/modes/base.py b/mindsdb/interfaces/agents/modes/base.py
index 97376b2a2af..1ec13d9242c 100644
--- a/mindsdb/interfaces/agents/modes/base.py
+++ b/mindsdb/interfaces/agents/modes/base.py
@@ -8,6 +8,10 @@ class PlanResponse(BaseModel):
     estimated_steps: int = Field(..., description="Estimated number of steps needed to solve the question")
 
 
+class TestResponse(BaseModel):
+    text: str = Field(..., description="Text response to the user")
+
+
 class ResponseType:
     FINAL_QUERY = "final_query"  # this is the final query
     EXPLORATORY = "exploratory_query"  # this is a query to explore and collect info to solve the challenge (e.g., distinct values of a categorical column, schema inference, etc.)
diff --git a/mindsdb/interfaces/agents/provider_utils.py b/mindsdb/interfaces/agents/provider_utils.py
deleted file mode 100644
index 8447102fb1b..00000000000
--- a/mindsdb/interfaces/agents/provider_utils.py
+++ /dev/null
@@ -1,40 +0,0 @@
-"""Utilities for working with agent providers.
-
-These helpers are intentionally free of heavy optional dependencies so they can
-be imported in lightweight builds where LangChain is not installed.
-"""
-
-from typing import Dict
-
-from mindsdb.interfaces.agents.constants import (
-    ANTHROPIC_CHAT_MODELS,
-    GOOGLE_GEMINI_CHAT_MODELS,
-    NVIDIA_NIM_CHAT_MODELS,
-    OLLAMA_CHAT_MODELS,
-    OPEN_AI_CHAT_MODELS,
-    WRITER_CHAT_MODELS,
-)
-
-
-def get_llm_provider(args: Dict) -> str:
-    """Infer the LLM provider from the supplied arguments."""
-
-    # Prefer an explicitly provided provider.
-    if "provider" in args:
-        return args["provider"]
-
-    model_name = args.get("model_name")
-    if model_name in ANTHROPIC_CHAT_MODELS:
-        return "anthropic"
-    if model_name in OPEN_AI_CHAT_MODELS:
-        return "openai"
-    if model_name in OLLAMA_CHAT_MODELS:
-        return "ollama"
-    if model_name in NVIDIA_NIM_CHAT_MODELS:
-        return "nvidia_nim"
-    if model_name in GOOGLE_GEMINI_CHAT_MODELS:
-        return "google"
-    if model_name in WRITER_CHAT_MODELS:
-        return "writer"
-
-    raise ValueError("Invalid model name. Please define a supported llm provider")
diff --git a/mindsdb/interfaces/agents/pydantic_ai_agent.py b/mindsdb/interfaces/agents/pydantic_ai_agent.py
index f32fb3d8ed3..7a38c57b165 100644
--- a/mindsdb/interfaces/agents/pydantic_ai_agent.py
+++ b/mindsdb/interfaces/agents/pydantic_ai_agent.py
@@ -25,7 +25,7 @@
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities.langfuse import LangfuseClientWrapper
 from mindsdb.interfaces.agents.modes import sql as sql_mode, text_sql as text_sql_mode
-from mindsdb.interfaces.agents.modes.base import ResponseType, PlanResponse
+from mindsdb.interfaces.agents.modes.base import ResponseType, PlanResponse, TestResponse
 
 logger = log.getLogger(__name__)
 DEBUG_LOGGER = logger.debug
@@ -65,6 +65,12 @@ def wrapper(self, messages, *args, **kwargs):
     return decorator
 
 
+def check_agent_llm(llm_params):
+    model = get_model_instance_from_kwargs(llm_params)
+    agent = Agent(model, output_type=TestResponse)
+    agent.run_sync("Say 'hi'")
+
+
 class PydanticAIAgent:
     """Pydantic AI-based agent to replace LangchainAgent"""
 
@@ -87,10 +93,6 @@ def __init__(
         self.llm: Optional[object] = None
         self.embedding_model: Optional[object] = None
 
-        self.log_callback_handler: Optional[object] = None
-        self.langfuse_callback_handler: Optional[object] = None
-        self.mdb_langfuse_callback_handler: Optional[object] = None
-
         self.langfuse_client_wrapper = LangfuseClientWrapper()
         self.agent_mode = self.agent.params.get("mode", "text")
 
diff --git a/mindsdb/interfaces/agents/utils/pydantic_ai_model_factory.py b/mindsdb/interfaces/agents/utils/pydantic_ai_model_factory.py
index 8189542312e..aa72d5e2f99 100644
--- a/mindsdb/interfaces/agents/utils/pydantic_ai_model_factory.py
+++ b/mindsdb/interfaces/agents/utils/pydantic_ai_model_factory.py
@@ -52,7 +52,7 @@ def get_llm_provider(args: Dict) -> str:
         return "writer"
 
     # For vLLM, require explicit provider specification
-    raise ValueError("Invalid model name. Please define a supported llm provider")
+    raise ValueError(f"Invalid model name: {model_name}. Please define a supported llm provider")
 
 
 def get_embedding_model_provider(args: Dict) -> str:
diff --git a/mindsdb/interfaces/agents/utils/sql_toolkit.py b/mindsdb/interfaces/agents/utils/sql_toolkit.py
index 1468bc2fb75..9588ad6ecba 100644
--- a/mindsdb/interfaces/agents/utils/sql_toolkit.py
+++ b/mindsdb/interfaces/agents/utils/sql_toolkit.py
@@ -281,11 +281,11 @@ def _check_f(node, is_table=None, **kwargs):
 
         query_traversal(ast_query, _check_f)
 
-    def get_usable_table_names(self):
+    def get_usable_table_names(self, lazy=True):
         if not self.tables:
             # no tables allowed
             return []
-        if not self.tables.has_wildcard:
+        if not self.tables.has_wildcard and lazy:
             return self.tables.items
 
         result_tables = []
@@ -330,16 +330,19 @@ def get_usable_table_names(self):
 
         return result_tables
 
-    def get_usable_knowledge_base_names(self):
+    def get_usable_knowledge_base_names(self, lazy=True):
         if not self.knowledge_bases:
             # no tables allowed
             return []
-        if not self.knowledge_bases.has_wildcard:
+        if not self.knowledge_bases.has_wildcard and lazy:
             return self.knowledge_bases.items
 
         try:
             # Query to get all knowledge bases
-            ast_query = Show(category="Knowledge Bases")
+            ast_query = Select(
+                targets=[Identifier("PROJECT"), Identifier("NAME")],
+                from_table=Identifier(parts=["information_schema", "knowledge_bases"]),
+            )
             result = self.command_executor.execute_command(ast_query)
 
             kb_names = []
diff --git a/mindsdb/interfaces/database/database.py b/mindsdb/interfaces/database/database.py
index bbacc9c256a..3f0fb602ace 100644
--- a/mindsdb/interfaces/database/database.py
+++ b/mindsdb/interfaces/database/database.py
@@ -101,11 +101,15 @@ def get_dict(self, filter_type: Optional[str] = None, lowercase: bool = True):
 
     def get_integration(self, integration_id):
         # get integration by id
-
-        # TODO get directly from db?
-        for rec in self.get_list():
-            if rec["id"] == integration_id and rec["type"] == "data":
-                return {"name": rec["name"], "type": rec["type"], "engine": rec["engine"], "id": rec["id"]}
+        integration = self.integration_controller.get_by_id(integration_id)
+        if integration and integration.get("type", "data") == "data":
+            return {
+                "name": integration["name"],
+                "type": integration["type"],
+                "engine": integration["engine"],
+                "id": integration["id"],
+            }
+        return None
 
     def exists(self, db_name: str) -> bool:
         return db_name.lower() in self.get_dict()
diff --git a/mindsdb/interfaces/database/log.py b/mindsdb/interfaces/database/log.py
index bda24fa9f6b..4a3b9a15af9 100644
--- a/mindsdb/interfaces/database/log.py
+++ b/mindsdb/interfaces/database/log.py
@@ -9,13 +9,14 @@
 from mindsdb_sql_parser.utils import JoinType
 
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
-from mindsdb.integrations.utilities.query_traversal import query_traversal
 from mindsdb.utilities.functions import resolve_table_identifier
-from mindsdb.api.executor.utilities.sql import get_query_tables
 from mindsdb.utilities.exception import EntityNotExistsError
-import mindsdb.interfaces.storage.db as db
 from mindsdb.utilities.context import context as ctx
-from mindsdb.api.executor.datahub.classes.response import DataHubResponse
+from mindsdb.utilities.types.column import Column
+from mindsdb.integrations.utilities.query_traversal import query_traversal
+from mindsdb.integrations.libs.response import TableResponse
+import mindsdb.interfaces.storage.db as db
+from mindsdb.api.executor.utilities.sql import get_query_tables
 from mindsdb.api.executor.datahub.classes.tables_row import (
     TABLES_ROW_TYPE,
     TablesRow,
@@ -228,7 +229,7 @@ def get_tables_rows(self) -> List[TablesRow]:
             for table_name in self._tables.keys()
         ]
 
-    def query(self, query: Select = None, native_query: str = None, session=None) -> DataHubResponse:
+    def query(self, query: Select = None, native_query: str = None, session=None) -> TableResponse:
         if native_query is not None:
             if query is not None:
                 raise Exception("'query' and 'native_query' arguments can not be used together")
@@ -290,6 +291,5 @@ def check_columns(node, is_table, **kwargs):
                     df[df_column_name] = df[df_column_name].astype(column_type)
         # endregion
 
-        columns_info = [{"name": k, "type": v} for k, v in df.dtypes.items()]
-
-        return DataHubResponse(data_frame=df, columns=columns_info)
+        columns = [Column(name=k, dtype=v) for k, v in df.dtypes.items()]
+        return TableResponse(data=df, columns=columns, affected_rows=0)
diff --git a/mindsdb/interfaces/database/projects.py b/mindsdb/interfaces/database/projects.py
index d51811d3f04..5dcd66e83b6 100644
--- a/mindsdb/interfaces/database/projects.py
+++ b/mindsdb/interfaces/database/projects.py
@@ -8,7 +8,7 @@
 import numpy as np
 
 from mindsdb_sql_parser.ast.base import ASTNode
-from mindsdb_sql_parser.ast import Select, Star, Constant, Identifier, BinaryOperation
+from mindsdb_sql_parser.ast import Select, Star, Constant, Identifier, BinaryOperation, Join
 from mindsdb_sql_parser import parse_sql
 
 from mindsdb.interfaces.storage import db
@@ -125,7 +125,17 @@ def create_view(self, name: str, query: str, session):
 
             query_context_controller.set_context(query_context_controller.IGNORE_CONTEXT)
             try:
-                SQLQuery(ast_query, session=session, database=self.name)
+                resp = SQLQuery(ast_query, session=session, database=self.name)
+                columns = [col.name for col in resp.fetched_data.columns]
+                seen, duplicates = set(), set()
+                for col in columns:
+                    if col in seen:
+                        duplicates.add(col)
+                    else:
+                        seen.add(col)
+                if len(duplicates) > 0:
+                    raise ValueError(f"Found duplicated columns in the view: {', '.join(duplicates)}")
+
             finally:
                 query_context_controller.release_context(query_context_controller.IGNORE_CONTEXT)
 
@@ -185,29 +195,35 @@ def get_conditions_to_move(node):
                 #     column is not in black list AND (query has star(*) OR column in white list)
 
                 has_star = False
-                white_list, black_list = [], []
+                white_list, black_list = {}, []
                 for target in view_query.targets:
                     if isinstance(target, Star):
                         has_star = True
                     if isinstance(target, Identifier):
                         name = target.parts[-1].lower()
                         if target.alias is None or target.alias.parts[-1].lower() == name:
-                            white_list.append(name)
+                            white_list[name] = target
                     elif target.alias is not None:
                         black_list.append(target.alias.parts[-1].lower())
 
+                is_join = isinstance(view_query.from_table, Join)
                 view_where = view_query.where
                 for condition in conditions:
                     arg1, arg2 = condition.args
 
                     if isinstance(arg1, Identifier):
                         name = arg1.parts[-1].lower()
-                        if name in black_list or not (has_star or name in white_list):
+                        # don't move condition for join with Star
+                        if name in black_list or not (has_star and not is_join):
                             continue
+                        elif name in white_list:
+                            arg1 = white_list[name]
                     if isinstance(arg2, Identifier):
                         name = arg2.parts[-1].lower()
-                        if name in black_list or not (has_star or name in white_list):
+                        if name in black_list or not (has_star and not is_join):
                             continue
+                        elif name in white_list:
+                            arg2 = white_list[name]
 
                     # condition can be moved into view
                     condition2 = BinaryOperation(condition.op, [arg1, arg2])
@@ -224,7 +240,13 @@ def get_conditions_to_move(node):
 
         # combine outer query with view's query
         view_query.parentheses = True
+
+        # keep alias (column of the query might relate to it)
+        alias = query.from_table.alias if query.from_table.alias is not None else query.from_table
+        view_query.alias = Identifier(parts=[alias.parts[-1]])
+
         query.from_table = view_query
+
         return query
 
     def query_view(self, query: Select, session) -> pd.DataFrame:
diff --git a/mindsdb/interfaces/file/file_controller.py b/mindsdb/interfaces/file/file_controller.py
index 5dfa7c05360..cb1308a952f 100644
--- a/mindsdb/interfaces/file/file_controller.py
+++ b/mindsdb/interfaces/file/file_controller.py
@@ -169,6 +169,7 @@ def get_file_pages(self, source_path: str):
         """
         file_reader = FileReader(path=source_path)
         tables = file_reader.get_contents()
+        file_reader.close()
 
         pages_files = {}
         pages_index = {}
diff --git a/mindsdb/interfaces/functions/controller.py b/mindsdb/interfaces/functions/controller.py
index 6503e6af402..7f63fa8b2de 100644
--- a/mindsdb/interfaces/functions/controller.py
+++ b/mindsdb/interfaces/functions/controller.py
@@ -4,7 +4,6 @@
 from duckdb.typing import BIGINT, DOUBLE, VARCHAR, BLOB, BOOLEAN
 
 from mindsdb.interfaces.storage.model_fs import HandlerStorage
-from mindsdb.integrations.libs.llm.utils import get_llm_config
 from mindsdb.utilities.config import config
 
 
@@ -140,10 +139,7 @@ def llm_call_function(self, node):
         try:
             from mindsdb.interfaces.knowledge_base.llm_client import LLMClient
 
-            llm_config = get_llm_config(chat_model_params["provider"], chat_model_params)
-            chat_model_params = llm_config.model_dump(by_alias=True)
-            chat_model_params = {k: v for k, v in chat_model_params.items() if v is not None}
-
+            chat_model_params.pop("api_keys", None)
             llm = LLMClient(chat_model_params, session=self.session)
         except Exception as e:
             raise RuntimeError(f"Unable to use LLM function, check ENV variables: {e}") from e
diff --git a/mindsdb/interfaces/jobs/jobs_controller.py b/mindsdb/interfaces/jobs/jobs_controller.py
index 31382daedf1..5c85372ffb1 100644
--- a/mindsdb/interfaces/jobs/jobs_controller.py
+++ b/mindsdb/interfaces/jobs/jobs_controller.py
@@ -16,6 +16,7 @@
 from mindsdb.interfaces.database.projects import ProjectController
 from mindsdb.interfaces.query_context.context_controller import query_context_controller
 from mindsdb.interfaces.database.log import LogDBController
+from mindsdb.integrations.libs.response import TableResponse
 
 from mindsdb.utilities import log
 
@@ -346,9 +347,9 @@ def get_history(self, name: str, project_name: str) -> List[dict]:
                 ],
             ),
         )
-        response = logs_db_controller.query(query)
+        response: TableResponse = logs_db_controller.query(query)
 
-        names = [i["name"] for i in response.columns]
+        names = [i.name for i in response.columns]
         return response.data_frame[names].to_dict(orient="records")
 
 
diff --git a/mindsdb/interfaces/knowledge_base/controller.py b/mindsdb/interfaces/knowledge_base/controller.py
index c9703bd1ada..0ba95236119 100644
--- a/mindsdb/interfaces/knowledge_base/controller.py
+++ b/mindsdb/interfaces/knowledge_base/controller.py
@@ -1,4 +1,3 @@
-import os
 import copy
 from typing import Dict, List, Optional, Any, Text, Tuple, Union
 import json
@@ -6,7 +5,7 @@
 
 import pandas as pd
 import numpy as np
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel
 from sqlalchemy.orm.attributes import flag_modified
 
 from mindsdb_sql_parser.ast import BinaryOperation, Constant, Identifier, Select, Update, Delete, Star
@@ -17,45 +16,36 @@
 
 import mindsdb.interfaces.storage.db as db
 from mindsdb.integrations.libs.vectordatabase_handler import (
-    DistanceFunction,
     TableField,
     VectorStoreHandler,
 )
 from mindsdb.integrations.utilities.handler_utils import get_api_key
 from mindsdb.integrations.utilities.handlers.auth_utilities.snowflake import get_validated_jwt
 
-from mindsdb.integrations.utilities.rag.settings import RerankerMode
-
-from mindsdb.interfaces.agents.utils.constants import DEFAULT_EMBEDDINGS_MODEL_PROVIDER, MAX_INSERT_BATCH_SIZE
+from mindsdb.interfaces.agents.utils.constants import MAX_INSERT_BATCH_SIZE
 from mindsdb.interfaces.database.projects import ProjectController
 from mindsdb.interfaces.knowledge_base.preprocessing.models import PreprocessingConfig, Document
 from mindsdb.interfaces.knowledge_base.preprocessing.document_preprocessor import PreprocessorFactory
 from mindsdb.interfaces.knowledge_base.evaluate import EvaluateBase
 from mindsdb.interfaces.knowledge_base.executor import KnowledgeBaseQueryExecutor
+from mindsdb.interfaces.knowledge_base.default_storage_resolver import resolve_default_storage_engines
 from mindsdb.interfaces.model.functions import PredictorRecordNotFound
 from mindsdb.utilities.exception import EntityExistsError, EntityNotExistsError
-from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator, KeywordSearchArgs
 from mindsdb.utilities.config import config
 from mindsdb.utilities.context import context as ctx
-from mindsdb.interfaces.agents.utils.pydantic_ai_model_factory import get_llm_provider
-from mindsdb.interfaces.knowledge_base.llm_wrapper import create_chat_model
+from mindsdb.utilities.utils import validate_pydantic_params
+from mindsdb.utilities import log
 
 from mindsdb.api.executor.command_executor import ExecuteCommands
 from mindsdb.api.executor.utilities.sql import query_df
-from mindsdb.utilities import log
+from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator, KeywordSearchArgs
+from mindsdb.integrations.utilities.rag.settings import RerankerMode, RerankerConfig
 from mindsdb.integrations.utilities.rag.rerankers.base_reranker import BaseLLMReranker, ListwiseLLMReranker
 from mindsdb.interfaces.knowledge_base.llm_client import LLMClient
 
 logger = log.getLogger(__name__)
 
 
-def _require_agent_extra(feature: str):
-    if create_chat_model is None:
-        raise ImportError(
-            f"{feature} requires the optional agent dependencies. Install them via `pip install mindsdb[kb]`."
-        )
-
-
 class KnowledgeBaseInputParams(BaseModel):
     metadata_columns: List[str] | None = None
     content_columns: List[str] | None = None
@@ -93,37 +83,10 @@ def get_model_params(model_params: dict, default_config_key: str):
     return combined_model_params
 
 
-def adapt_embedding_model_params(embedding_model_params: dict):
-    """
-    Prepare parameters for embedding model.
-    """
-    params_copy = copy.deepcopy(embedding_model_params)
-    provider = params_copy.pop("provider", None).lower()
-    api_key = get_api_key(provider, params_copy, strict=False) or params_copy.get("api_key")
-    # Underscores are replaced because the provider name ultimately gets mapped to a class name.
-    # This is mostly to support Azure OpenAI (azure_openai); the mapped class name is 'AzureOpenAIEmbeddings'.
-    params_copy["class"] = provider.replace("_", "")
-    if provider == "azure_openai":
-        # Azure OpenAI expects the api_key to be passed as 'openai_api_key'.
-        params_copy["openai_api_key"] = api_key
-        params_copy["azure_endpoint"] = params_copy.pop("base_url")
-        if "chunk_size" not in params_copy:
-            params_copy["chunk_size"] = 2048
-        if "api_version" in params_copy:
-            params_copy["openai_api_version"] = params_copy["api_version"]
-    else:
-        params_copy[f"{provider}_api_key"] = api_key
-    params_copy.pop("api_key", None)
-    params_copy["model"] = params_copy.pop("model_name", None)
-
-    return params_copy
-
-
 def get_reranking_model_from_params(reranking_model_params: dict):
     """
     Create reranking model from parameters.
     """
-    from mindsdb.integrations.utilities.rag.settings import RerankerConfig
 
     # Work on a copy; do not mutate caller's dict
     params_copy = copy.deepcopy(reranking_model_params)
@@ -179,7 +142,7 @@ def rotate_provider_api_key(params):
     :param params: input params, can be modified by this function
     :return: a new api key if it is refreshed
     """
-    provider = params.get("provider").lower()
+    provider = params.get("provider", "").lower()
 
     if provider == "snowflake":
         if "snowflake_account_id" in params:
@@ -673,30 +636,6 @@ def delete_query(self, query: Delete):
         self.addapt_conditions_columns(conditions)
         db_handler.dispatch_delete(query, conditions)
 
-    def hybrid_search(
-        self,
-        query: str,
-        keywords: List[str] = None,
-        metadata: Dict[str, str] = None,
-        distance_function=DistanceFunction.COSINE_DISTANCE,
-    ) -> pd.DataFrame:
-        query_df = pd.DataFrame.from_records([{TableField.CONTENT.value: query}])
-        embeddings_df = self._df_to_embeddings(query_df)
-        if embeddings_df.empty:
-            return pd.DataFrame([])
-        embeddings = embeddings_df.iloc[0][TableField.EMBEDDINGS.value]
-        keywords_query = None
-        if keywords is not None:
-            keywords_query = " ".join(keywords)
-        db_handler = self.get_vector_db()
-        return db_handler.hybrid_search(
-            self._kb.vector_database_table,
-            embeddings,
-            query=keywords_query,
-            metadata=metadata,
-            distance_function=distance_function,
-        )
-
     def clear(self):
         """
         Clear data in KB table
@@ -1023,91 +962,6 @@ def _content_to_embeddings(self, content: str) -> List[float]:
         res = self._df_to_embeddings(df)
         return res[TableField.EMBEDDINGS.value][0]
 
-    @staticmethod
-    def call_litellm_embedding(session, model_params, messages):
-        args = copy.deepcopy(model_params)
-
-        if "model_name" not in args:
-            raise ValueError("'model_name' must be provided for embedding model")
-
-        llm_model = args.pop("model_name")
-        engine = args.pop("provider")
-
-        module = session.integration_controller.get_handler_module("litellm")
-        if module is None or module.Handler is None:
-            raise ValueError(f'Unable to use "{engine}" provider. Litellm handler is not installed')
-        return module.Handler.embeddings(engine, llm_model, messages, args)
-
-    def build_rag_pipeline(self, retrieval_config: dict):
-        """
-        Builds a RAG pipeline with returned sources
-
-        Args:
-            retrieval_config: dict with retrieval config
-
-        Returns:
-            RAG: Configured RAG pipeline instance
-
-        Raises:
-            ValueError: If the configuration is invalid or required components are missing
-        """
-        # Get embedding model from knowledge base
-        from mindsdb.interfaces.knowledge_base.embedding_model_utils import construct_embedding_model_from_args
-        from mindsdb.integrations.utilities.rag.rag_pipeline_builder import RAG
-        from mindsdb.integrations.utilities.rag.config_loader import load_rag_config
-
-        embedding_model_params = get_model_params(self._kb.params.get("embedding_model", {}), "default_embedding_model")
-        if self._kb.embedding_model:
-            # Extract embedding model args from knowledge base table
-            embedding_args = self._kb.embedding_model.learn_args.get("using", {})
-            # Construct the embedding model directly
-            embeddings_model = construct_embedding_model_from_args(embedding_args, session=self.session)
-            logger.debug(f"Using knowledge base embedding model with args: {embedding_args}")
-        elif embedding_model_params:
-            embeddings_model = construct_embedding_model_from_args(
-                adapt_embedding_model_params(embedding_model_params), session=self.session
-            )
-            logger.debug(f"Using knowledge base embedding model from params: {self._kb.params['embedding_model']}")
-        else:
-            # Use default embedding model with default provider
-            # Default to OpenAI's text-embedding-3-small for OpenAI provider, otherwise let the provider choose
-            default_model_name = "text-embedding-3-small" if DEFAULT_EMBEDDINGS_MODEL_PROVIDER == "openai" else None
-            default_embedding_args = {
-                "provider": DEFAULT_EMBEDDINGS_MODEL_PROVIDER,
-            }
-            if default_model_name:
-                default_embedding_args["model_name"] = default_model_name
-            embeddings_model = construct_embedding_model_from_args(default_embedding_args, session=self.session)
-            logger.debug(
-                f"Using default embedding model ({DEFAULT_EMBEDDINGS_MODEL_PROVIDER}) as knowledge base has no embedding model"
-            )
-
-        # Update retrieval config with knowledge base parameters
-        kb_params = {"vector_store_config": {"kb_table": self}}
-
-        # Load and validate config
-        try:
-            rag_config = load_rag_config(retrieval_config, kb_params, embeddings_model)
-
-            # Build LLM if specified
-            if "llm_model_name" in rag_config:
-                llm_args = {"model_name": rag_config.llm_model_name}
-                if not rag_config.llm_provider:
-                    llm_args["provider"] = get_llm_provider(llm_args)
-                else:
-                    llm_args["provider"] = rag_config.llm_provider
-                _require_agent_extra("Building knowledge base retrieval pipelines")
-                rag_config.llm = create_chat_model(llm_args)
-
-            # Create RAG pipeline
-            rag = RAG(rag_config)
-            logger.debug(f"RAG pipeline created with config: {rag_config}")
-            return rag
-
-        except Exception as e:
-            logger.exception("Error building RAG pipeline:")
-            raise ValueError(f"Failed to build RAG pipeline: {str(e)}") from e
-
     def _parse_metadata(self, base_metadata):
         """Helper function to robustly parse metadata string to dict"""
         if isinstance(base_metadata, dict):
@@ -1128,36 +982,6 @@ def _generate_document_id(self, content: str, content_column: str, provided_id:
 
         return generate_document_id(content=content, provided_id=provided_id)
 
-    def _convert_metadata_value(self, value):
-        """
-        Convert metadata value to appropriate Python type.
-
-        Args:
-            value: The value to convert
-
-        Returns:
-            Converted value in appropriate Python type
-        """
-        if pd.isna(value):
-            return None
-
-        # Handle pandas/numpy types
-        if pd.api.types.is_datetime64_any_dtype(value) or isinstance(value, pd.Timestamp):
-            return str(value)
-        elif pd.api.types.is_integer_dtype(type(value)):
-            return int(value)
-        elif pd.api.types.is_float_dtype(type(value)):
-            return float(value)
-        elif pd.api.types.is_bool_dtype(type(value)):
-            return bool(value)
-
-        # Handle basic Python types
-        if isinstance(value, (int, float, bool)):
-            return value
-
-        # Convert everything else to string
-        return str(value)
-
     def create_index(self, params: dict = None):
         """
         Create an index on the knowledge base table
@@ -1179,26 +1003,6 @@ class KnowledgeBaseController:
     def __init__(self, session) -> None:
         self.session = session
 
-    def _check_kb_input_params(self, params):
-        # check names and types KB params
-        try:
-            KnowledgeBaseInputParams.model_validate(params)
-        except ValidationError as e:
-            problems = []
-            for error in e.errors():
-                parameter = ".".join([str(i) for i in error["loc"]])
-                param_type = error["type"]
-                if param_type == "extra_forbidden":
-                    msg = f"Parameter '{parameter}' is not allowed"
-                else:
-                    msg = f"Error in '{parameter}' (type: {param_type}): {error['msg']}. Input: {repr(error['input'])}"
-                problems.append(msg)
-
-            msg = "\n".join(problems)
-            if len(problems) > 1:
-                msg = "\n" + msg
-            raise ValueError(f"Problem with knowledge base parameters: {msg}") from e
-
     def add(
         self,
         name: str,
@@ -1220,10 +1024,9 @@ def add(
         # Validate preprocessing config first if provided
         if preprocessing_config is not None:
             PreprocessingConfig(**preprocessing_config)  # Validate before storing
-            params = params or {}
             params["preprocessing"] = preprocessing_config
 
-        self._check_kb_input_params(params)
+        validate_pydantic_params(params, KnowledgeBaseInputParams, "knowledge base")
 
         # Check if vector_size is provided when using sparse vectors
         is_sparse = params.get("is_sparse")
@@ -1243,6 +1046,9 @@ def add(
             raise EntityExistsError("Knowledge base already exists", name)
 
         embedding_params = get_model_params(params.get("embedding_model", {}), "default_embedding_model")
+        if not bool(embedding_params):
+            raise ValueError("No embedding model parameters provided")
+
         params["embedding_model"] = embedding_params
         rotate_provider_api_key(embedding_params)
 
@@ -1270,24 +1076,12 @@ def add(
 
         # search for the vector database table
         if storage is None:
-            cloud_pg_vector = os.environ.get("KB_PGVECTOR_URL")
-            if cloud_pg_vector:
-                vector_table_name = name
-                # Add sparse vector support for pgvector
-                vector_db_params = {}
-                # Check both explicit parameter and model configuration
-                if is_sparse:
-                    vector_db_params["is_sparse"] = True
-                    if vector_size is not None:
-                        vector_db_params["vector_size"] = vector_size
-                vector_db_name = self._create_persistent_pgvector(vector_db_params)
-                params["default_vector_storage"] = vector_db_name
-            else:
-                raise ValueError(
-                    "Vector table is not defined. Set it by `storage=vector_db.vector_table`. "
-                    "One of the options is to use pgvector: "
-                    "https://docs.mindsdb.com/integrations/vector-db-integrations/pgvector"
-                )
+            vector_db_name, vector_table_name = self._resolve_default_vector_storage(
+                kb_name=name,
+                is_sparse=is_sparse,
+                vector_size=vector_size,
+            )
+            params["default_vector_storage"] = vector_db_name
         elif len(storage.parts) != 2:
             raise ValueError("Storage param has to be vector db with table")
         else:
@@ -1376,7 +1170,7 @@ def update(
             params = params or {}
             params["preprocessing"] = preprocessing_config
 
-        self._check_kb_input_params(params)
+        validate_pydantic_params(params, KnowledgeBaseInputParams, "knowledge base")
 
         # get project id
         project = self.session.database_controller.get_project(project_name)
@@ -1465,21 +1259,44 @@ def _create_persistent_pgvector(self, params=None):
         self.session.integration_controller.add(vector_store_name, "pgvector", params or {})
         return vector_store_name
 
-    def _create_persistent_chroma(self, kb_name, engine="chromadb"):
-        """Create default vector database for knowledge base, if not specified"""
-
-        vector_store_name = f"{kb_name}_{engine}"
-
-        vector_store_folder_name = f"{vector_store_name}"
-        connection_args = {"persist_directory": vector_store_folder_name}
+    def _create_persistent_faiss(self, kb_name: str):
+        vector_store_name = f"store_{kb_name}"
 
         # check if exists
         if self.session.integration_controller.get(vector_store_name):
             return vector_store_name
 
-        self.session.integration_controller.add(vector_store_name, engine, connection_args)
+        self.session.integration_controller.add(vector_store_name, "duckdb_faiss", {})
         return vector_store_name
 
+    def _resolve_default_vector_storage(self, kb_name: str, is_sparse: bool = False, vector_size: int = None):
+        resolved_storage = resolve_default_storage_engines(config)
+        default_engine = resolved_storage["default_storage"]
+
+        if default_engine is None:
+            raise ValueError(
+                "Vector table is not defined. Set it by `storage=vector_db.vector_table` or configure "
+                "`knowledge_bases.storage` as one of: pgvector, faiss."
+            )
+
+        if default_engine == "pgvector":
+            vector_db_params = {}
+            if is_sparse:
+                vector_db_params["is_sparse"] = True
+                if vector_size is not None:
+                    vector_db_params["vector_size"] = vector_size
+            vector_db_name = self._create_persistent_pgvector(vector_db_params)
+            return vector_db_name, kb_name
+
+        if default_engine in ("duckdb_faiss", "faiss"):
+            vector_db_name = self._create_persistent_faiss(kb_name)
+            return vector_db_name, kb_name
+
+        raise ValueError(
+            f"Automatic default storage creation is not supported for engine '{default_engine}'. "
+            "Set `storage=vector_db.vector_table` explicitly."
+        )
+
     def _check_embedding_model(self, project_name, params: dict = None, kb_name="") -> dict:
         """check embedding model for knowledge base, return embedding model info"""
 
@@ -1510,7 +1327,7 @@ def _check_embedding_model(self, project_name, params: dict = None, kb_name="")
         except Exception as e:
             raise RuntimeError(f"Problem with embedding model config: {e}") from e
 
-    def delete(self, name: str, project_name: int, if_exists: bool = False) -> None:
+    def delete(self, name: str, project_name: str, if_exists: bool = False) -> None:
         """
         Delete a knowledge base from the database
         """
@@ -1629,3 +1446,26 @@ def evaluate(self, table_name: str, project_name: str, params: dict = None) -> p
         scores = EvaluateBase.run(self.session, kb_table, params)
 
         return scores
+
+    def release_lock(self, knowledge_base: Identifier, project_name):
+        # works only for FAISS dbs.
+        # if FAISS vector db is used in KB: remove this db from handlers cache.
+        #   it will clear internal cache of tables in faiss handler and release locks for faiss files
+        #   return unloaded database name
+
+        if len(knowledge_base.parts) > 1:
+            project_name, kb_name = knowledge_base.parts[-2:]
+        else:
+            kb_name = knowledge_base.parts[-1]
+
+        project_id = self.session.database_controller.get_project(project_name).id
+        kb = self.get(kb_name, project_id)
+        if kb is None or kb.vector_database_id is None:
+            return
+        database = db.Integration.query.get(kb.vector_database_id)
+        if database is None:
+            return
+
+        if database.engine == "duckdb_faiss":
+            self.session.integration_controller.handlers_cache.delete(database.name)
+            return database.name
diff --git a/mindsdb/interfaces/knowledge_base/default_storage_resolver.py b/mindsdb/interfaces/knowledge_base/default_storage_resolver.py
new file mode 100644
index 00000000000..93a4c364054
--- /dev/null
+++ b/mindsdb/interfaces/knowledge_base/default_storage_resolver.py
@@ -0,0 +1,90 @@
+import os
+from typing import Any
+
+from mindsdb.utilities.config import config
+
+
+def _normalize_engine_name(engine: str | None) -> str | None:
+    if engine is None:
+        return None
+    normalized = engine.strip().lower()
+    if normalized in ("duckdb_faiss", "faiss"):
+        return "faiss"
+    if normalized == "pgvector":
+        return "pgvector"
+    return normalized or None
+
+
+def _get_env_available_engines() -> list[str]:
+    engines: list[str] = ["faiss"]
+    if os.environ.get("KB_PGVECTOR_URL"):
+        engines.append("pgvector")
+    return engines
+
+
+def get_env_available_engines() -> list[str]:
+    return _get_env_available_engines()
+
+
+def get_knowledge_base_storage_config(config_obj=None) -> str | None:
+    config_obj = config_obj or config
+    storage = config_obj.get("knowledge_bases", {}).get("storage", None)
+
+    if storage is None:
+        return None
+
+    if isinstance(storage, list):
+        if len(storage) == 0:
+            return None
+        storage = storage[0]
+
+    if not isinstance(storage, str):
+        raise ValueError("knowledge_bases.storage must be a string value")
+
+    return _normalize_engine_name(storage)
+
+
+def _unique_default_first(default: str | None, ordered: list[str]) -> list[str]:
+    """Return `ordered` with `default` first if set, dropping later duplicates."""
+    out: list[str] = []
+    seen: set[str] = set()
+    for engine in ([default] if default else []) + ordered:
+        if engine not in seen:
+            seen.add(engine)
+            out.append(engine)
+    return out
+
+
+def resolve_default_storage_engines(config_obj=None) -> dict[str, Any]:
+    configured = get_knowledge_base_storage_config(config_obj)
+    pgvector_enabled = os.environ.get("KB_PGVECTOR_URL") is not None
+    available = _get_env_available_engines()
+
+    if configured and configured not in available:
+        available = [configured, *available]
+
+    default = configured
+    if default is None:
+        default = "pgvector" if pgvector_enabled else None
+    if default is None and available:
+        default = available[0]
+
+    candidates = _unique_default_first(default, available)
+    available_set = set(available)
+    resolved_storage = [
+        {
+            "engine": name,
+            "available": name in available_set,
+            "default": name == default,
+            "source": "config" if configured == name else "fallback",
+        }
+        for name in candidates
+    ]
+
+    return {
+        "storage": configured,
+        "resolved_storage": resolved_storage,
+        "default_storage": default,
+        "available_vector_engines": available,
+        "pgvector_enabled": pgvector_enabled,
+    }
diff --git a/mindsdb/interfaces/knowledge_base/embedding_model_utils.py b/mindsdb/interfaces/knowledge_base/embedding_model_utils.py
deleted file mode 100644
index f8f151d7863..00000000000
--- a/mindsdb/interfaces/knowledge_base/embedding_model_utils.py
+++ /dev/null
@@ -1,95 +0,0 @@
-"""Custom embedding model utilities to replace langchain construct_model_from_args"""
-
-import copy
-from typing import Dict, Any, List
-
-from mindsdb.interfaces.knowledge_base.llm_client import LLMClient
-from mindsdb.utilities import log
-
-logger = log.getLogger(__name__)
-
-
-class CustomEmbeddingModel:
-    """
-    Custom embedding model wrapper that uses LLMClient for embeddings.
-    This replaces langchain embedding models for use in knowledge_base.
-    """
-
-    def __init__(self, args: Dict[str, Any], session=None):
-        """
-        Initialize the embedding model
-
-        Args:
-            args: Dictionary with model parameters (model_name, provider, etc.)
-            session: Optional session for LLMClient
-        """
-        # Prepare params for LLMClient
-        # Handle model_name -> model mapping if needed
-        params = {
-            "model_name": args.get("model", args.get("model_name")),
-            "provider": args.get("provider", "openai"),
-            **{k: v for k, v in args.items() if k not in ["model", "model_name", "provider", "class", "target"]},
-        }
-
-        self.llm_client = LLMClient(params=params, session=session)
-        self.model_name = params["model_name"]
-
-    def embed_query(self, text: str) -> List[float]:
-        """
-        Embed a single query string
-
-        Args:
-            text: Text to embed
-
-        Returns:
-            List of floats representing the embedding vector
-        """
-        embeddings = self.llm_client.embeddings([text])
-        return embeddings[0] if embeddings else []
-
-    def embed_documents(self, texts: List[str]) -> List[List[float]]:
-        """
-        Embed a list of documents
-
-        Args:
-            texts: List of text strings to embed
-
-        Returns:
-            List of embedding vectors (each is a list of floats)
-        """
-        return self.llm_client.embeddings(texts)
-
-
-def construct_embedding_model_from_args(args: Dict[str, Any], session=None):
-    """
-    Construct an embedding model from arguments (replacement for langchain's construct_model_from_args)
-
-    Args:
-        args: Dictionary with embedding model parameters
-            - class: Embedding class name (for compatibility, but not used)
-            - model or model_name: Model name to use
-            - provider: Provider name (openai, etc.)
-            - Other provider-specific parameters
-        session: Optional session for LLMClient
-
-    Returns:
-        CustomEmbeddingModel instance
-    """
-    # Work on a copy to avoid mutating the original
-    args_copy = copy.deepcopy(args)
-
-    # Extract class name for logging (but we don't use it)
-    class_name = args_copy.pop("class", "OpenAIEmbeddings")
-    target = args_copy.pop("target", None)
-
-    logger.debug(f"Constructing embedding model with class: {class_name}, args: {args_copy}")
-
-    # Create the custom embedding model
-    model = CustomEmbeddingModel(args_copy, session=session)
-
-    # Restore args for compatibility (in case caller expects them)
-    if target is not None:
-        args["target"] = target
-    args["class"] = class_name
-
-    return model
diff --git a/mindsdb/interfaces/knowledge_base/llm_client.py b/mindsdb/interfaces/knowledge_base/llm_client.py
index ab044811b94..365e84c10e5 100644
--- a/mindsdb/interfaces/knowledge_base/llm_client.py
+++ b/mindsdb/interfaces/knowledge_base/llm_client.py
@@ -134,7 +134,6 @@ def completion(self, messages: List[dict], json_output: bool = False) -> List[st
         Call LLM completion and get response
         """
         params = self.params
-        params["json_output"] = json_output
         if self.engine == "openai":
             response = self.client.chat.completions.create(
                 model=params["model_name"],
@@ -143,6 +142,7 @@ def completion(self, messages: List[dict], json_output: bool = False) -> List[st
             return [item.message.content for item in response.choices]
         else:
             kwargs = params.copy()
+            params["json_output"] = json_output
             model = kwargs.pop("model_name")
             kwargs.pop("provider", None)
             response = self.client.completion(self.provider, model=model, messages=messages, args=kwargs)
diff --git a/mindsdb/interfaces/knowledge_base/preprocessing/constants.py b/mindsdb/interfaces/knowledge_base/preprocessing/constants.py
index 0e984c2c67a..47332c37b8b 100644
--- a/mindsdb/interfaces/knowledge_base/preprocessing/constants.py
+++ b/mindsdb/interfaces/knowledge_base/preprocessing/constants.py
@@ -1,13 +1,4 @@
-# Default settings for markdown header splitting
-DEFAULT_MARKDOWN_HEADERS = [
-    ("#", "Header 1"),
-    ("##", "Header 2"),
-    ("###", "Header 3"),
-]
-
 # Limits for web crawling
 DEFAULT_CRAWL_DEPTH = None
 DEFAULT_WEB_CRAWL_LIMIT = 1
 DEFAULT_WEB_FILTERS = []
-
-DEFAULT_CONTEXT_DOCUMENT_LIMIT = 50
diff --git a/mindsdb/interfaces/query_context/context_controller.py b/mindsdb/interfaces/query_context/context_controller.py
index 97a1ec83189..08188c8ed66 100644
--- a/mindsdb/interfaces/query_context/context_controller.py
+++ b/mindsdb/interfaces/query_context/context_controller.py
@@ -1,9 +1,9 @@
-from typing import List, Optional, Iterable
 import pickle
 import datetime as dt
+from typing import List, Optional, Iterable
 
-from sqlalchemy.orm.attributes import flag_modified
 import pandas as pd
+from sqlalchemy.orm.attributes import flag_modified
 
 from mindsdb_sql_parser import Select, Star, OrderBy
 
@@ -17,7 +17,6 @@
 )
 from mindsdb.integrations.utilities.query_traversal import query_traversal
 from mindsdb.utilities.cache import get_cache
-
 from mindsdb.interfaces.storage import db
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities.config import config
@@ -70,14 +69,14 @@ def get_partitions(self, dn, step_call, query: Select) -> Iterable:
         :param query: AST query to execute
         :return: generator with query results
         """
-        if hasattr(dn, "has_support_stream") and dn.has_support_stream():
+        if dn.has_support_stream():
             query2 = self.get_partition_query(step_call.current_step_num, query, stream=True)
 
-            for df in dn.query_stream(query2, fetch_size=self.batch_size):
+            response = dn.query(query=query2, session=step_call.session)
+            for df in response.iterate_no_save():
                 max_track_value = self.get_max_track_value(df)
                 yield df
                 self.set_progress(max_track_value=max_track_value)
-
         else:
             while True:
                 query2 = self.get_partition_query(step_call.current_step_num, query, stream=False)
@@ -457,7 +456,7 @@ def _get_init_last_values(self, l_query: LastQuery, dn, session) -> dict:
 
                 idx = None
                 for i, col in enumerate(columns_info):
-                    if col["name"].upper() == info["column_name"].upper():
+                    if col.name.upper() == info["column_name"].upper():
                         idx = i
                         break
 
diff --git a/mindsdb/interfaces/query_context/last_query.py b/mindsdb/interfaces/query_context/last_query.py
index 1df233d4405..7e00a08c846 100644
--- a/mindsdb/interfaces/query_context/last_query.py
+++ b/mindsdb/interfaces/query_context/last_query.py
@@ -3,7 +3,17 @@
 from collections import defaultdict
 
 from mindsdb_sql_parser.ast import (
-    Identifier, Select, BinaryOperation, Last, Constant, Star, ASTNode, NullConstant, OrderBy, Function, TypeCast
+    Identifier,
+    Select,
+    BinaryOperation,
+    Last,
+    Constant,
+    Star,
+    ASTNode,
+    NullConstant,
+    OrderBy,
+    Function,
+    TypeCast,
 )
 from mindsdb.integrations.utilities.query_traversal import query_traversal
 
@@ -34,21 +44,21 @@ def __init__(self, query: ASTNode):
 
     def _find_last_columns(self, query: ASTNode) -> Union[dict, None]:
         """
-          This function:
-           - Searches LAST column in the input query
-           - Replaces it with constants and memorises link to these constants
-           - Link to constants will be used to inject values to query instead of LAST
-           - Provide checks:
-             - if it is possible to find the table for column
-             - if column in select target
-           - Generates and returns last_column variable which is dict
-                last_columns[table_name] = {
-                    'table': <table identifier>,
-                    'column': <column name>,
-                    'links': [<link to ast node>, ... ],
-                    'target_idx': <number of column in select target>,
-                    'gen_init_query': if true: to generate query to initial values for LAST
-                }
+        This function:
+         - Searches LAST column in the input query
+         - Replaces it with constants and memorises link to these constants
+         - Link to constants will be used to inject values to query instead of LAST
+         - Provide checks:
+           - if it is possible to find the table for column
+           - if column in select target
+         - Generates and returns last_column variable which is dict
+              last_columns[table_name] = {
+                  'table': <table identifier>,
+                  'column': <column name>,
+                  'links': [<link to ast node>, ... ],
+                  'target_idx': <number of column in select target>,
+                  'gen_init_query': if true: to generate query to initial values for LAST
+              }
         """
 
         # index last variables in query
@@ -76,7 +86,6 @@ def replace_last_in_tree(node: ASTNode, injected: Constant):
                         return found
 
         def index_query(node, is_table, parent_query, **kwargs):
-
             parent_query_id = id(parent_query)
             last = None
             if is_table and isinstance(node, Identifier):
@@ -105,13 +114,15 @@ def index_query(node, is_table, parent_query, **kwargs):
 
             if last is not None:
                 # memorize
-                conditions.append({
-                    'query_id': parent_query_id,
-                    'condition': node,
-                    'last': last,
-                    'column': col,
-                    'gen_init_query': gen_init_query  # generate query to fetch initial last values from table
-                })
+                conditions.append(
+                    {
+                        "query_id": parent_query_id,
+                        "condition": node,
+                        "last": last,
+                        "column": col,
+                        "gen_init_query": gen_init_query,  # generate query to fetch initial last values from table
+                    }
+                )
 
         # find lasts
         query_traversal(query, index_query)
@@ -122,7 +133,7 @@ def index_query(node, is_table, parent_query, **kwargs):
         self.query_orig = copy.deepcopy(query)
 
         for info in conditions:
-            self.last_idx[info['query_id']].append(info)
+            self.last_idx[info["query_id"]].append(info)
 
         # index query targets
         query_id = id(query)
@@ -152,21 +163,20 @@ def index_query(node, is_table, parent_query, **kwargs):
         last_columns = {}
         for parent_query_id, items in self.last_idx.items():
             for info in items:
-                col = info['column']
-                last = info['last']
+                col = info["column"]
+                last = info["last"]
                 tables = tables_idx[parent_query_id]
 
                 uniq_tables = len(set([id(v) for v in tables.values()]))
                 if len(col.parts) > 1:
-
                     table = tables.get(col.parts[-2])
                     if table is None:
-                        raise ValueError('cant find table')
+                        raise ValueError("cant find table")
                 elif uniq_tables == 1:
                     table = list(tables.values())[0]
                 else:
                     # or just skip it?
-                    raise ValueError('cant find table')
+                    raise ValueError("cant find table")
 
                 col_name = col.parts[-1]
 
@@ -179,29 +189,46 @@ def index_query(node, is_table, parent_query, **kwargs):
                             # will try to get by name
                             ...
                         else:
-                            raise ValueError('Last value should be in query target')
+                            raise ValueError("Last value should be in query target")
 
                     last_columns[table_name] = {
-                        'table': table,
-                        'column': col_name,
-                        'links': [last],
-                        'target_idx': target_idx,
-                        'gen_init_query': info['gen_init_query']
+                        "table": table,
+                        "column": col_name,
+                        "links": [last],
+                        "target_idx": target_idx,
+                        "gen_init_query": info["gen_init_query"],
                     }
 
-                elif last_columns[table_name]['column'] == col_name:
-                    last_columns[table_name]['column'].append(last)
+                elif last_columns[table_name]["column"] == col_name:
+                    last_columns[table_name]["column"].append(last)
                 else:
-                    raise ValueError('possible to use only one column')
+                    raise ValueError("possible to use only one column")
 
         return last_columns
 
     def to_string(self) -> str:
         """
-            String representation of the query
-            Used to identify query in query_context table
+        String representation of the query
+        Used to identify query in query_context table
         """
-        return self.query_orig.to_string()
+        query = self.query_orig
+        if isinstance(query.from_table, Select) and query.targets == [Star()]:
+            # simplify nested query
+            if (
+                query.group_by is None
+                and query.order_by is None
+                and query.having is None
+                and query.distinct is False
+                and query.where is None
+                and query.limit is None
+                and query.offset is None
+                and query.cte is None
+            ):
+                query = copy.deepcopy(query.from_table)
+                query.parentheses = False
+                query.alias = None
+
+        return query.to_string()
 
     def get_last_columns(self) -> List[dict]:
         """
@@ -210,11 +237,11 @@ def get_last_columns(self) -> List[dict]:
         """
         return [
             {
-                'table': info['table'],
-                'table_name': table_name,
-                'column_name': info['column'],
-                'target_idx': info['target_idx'],
-                'gen_init_query': info['gen_init_query'],
+                "table": info["table"],
+                "table_name": table_name,
+                "column_name": info["column"],
+                "target_idx": info["target_idx"],
+                "gen_init_query": info["gen_init_query"],
             }
             for table_name, info in self.last_tables.items()
         ]
@@ -224,8 +251,8 @@ def apply_values(self, values: dict) -> ASTNode:
         Fills query with new values and return it
         """
         for table_name, info in self.last_tables.items():
-            value = values.get(table_name, {}).get(info['column'])
-            for last in info['links']:
+            value = values.get(table_name, {}).get(info["column"])
+            for last in info["links"]:
                 last.value = value
 
         return self.query
@@ -239,9 +266,9 @@ def get_init_queries(self):
         # replace values
         for items in self.last_idx.values():
             for info in items:
-                node = info['condition']
+                node = info["condition"]
                 back_up_values.append([node.op, node.args[1]])
-                node.op = 'is not'
+                node.op = "is not"
                 node.args[1] = NullConstant()
 
         query2 = copy.deepcopy(self.query)
@@ -249,18 +276,16 @@ def get_init_queries(self):
         # return values
         for items in self.last_idx.values():
             for info in items:
-                node = info['condition']
+                node = info["condition"]
                 op, arg1 = back_up_values.pop(0)
                 node.op = op
                 node.args[1] = arg1
 
         for info in self.get_last_columns():
-            if not info['gen_init_query']:
+            if not info["gen_init_query"]:
                 continue
-            col = Identifier(info['column_name'])
+            col = Identifier(info["column_name"])
             query2.targets = [col]
-            query2.order_by = [
-                OrderBy(col, direction='DESC')
-            ]
+            query2.order_by = [OrderBy(col, direction="DESC")]
             query2.limit = Constant(1)
             yield query2, info
diff --git a/mindsdb/interfaces/query_context/query_task.py b/mindsdb/interfaces/query_context/query_task.py
index 57cc62d7f81..97cbbdcbf26 100644
--- a/mindsdb/interfaces/query_context/query_task.py
+++ b/mindsdb/interfaces/query_context/query_task.py
@@ -10,7 +10,6 @@ def __init__(self, *args, **kwargs):
         self.query_id = self.object_id
 
     def run(self, stop_event):
-
         try:
             session = SessionController()
             SQLQuery(None, query_id=self.query_id, session=session, stop_event=stop_event)
diff --git a/mindsdb/interfaces/tasks/task_thread.py b/mindsdb/interfaces/tasks/task_thread.py
index f753a59928a..8b9eb7ca9e5 100644
--- a/mindsdb/interfaces/tasks/task_thread.py
+++ b/mindsdb/interfaces/tasks/task_thread.py
@@ -23,6 +23,9 @@ def run(self):
         # create context and session
 
         task_record = db.Tasks.query.get(self.task_id)
+        if task_record is None:
+            logger.error(f"Task record not found: {self.task_id}")
+            return
 
         ctx.set_default()
         ctx.company_id = task_record.company_id
diff --git a/mindsdb/utilities/config.py b/mindsdb/utilities/config.py
index 82a857b00c7..b534a4c5a98 100644
--- a/mindsdb/utilities/config.py
+++ b/mindsdb/utilities/config.py
@@ -13,6 +13,49 @@
 # NOTE do not `import from mindsdb` here
 
 
+def get_bool_env_var(env_name: str) -> bool:
+    """Read an environment variable and return its value as a boolean.
+
+    Args:
+        env_name (str): name of the environment variable to read.
+
+    Returns:
+        bool: True or False, or None if the variable is not set or empty.
+
+    Raises:
+        ValueError: if the value is set but does not match any known boolean representation.
+    """
+    value = os.environ.get(env_name)
+    if value is None or value == "":
+        return None
+    match value.lower():
+        case "1" | "true" | "on" | "yes" | "y":
+            value = True
+        case "0" | "false" | "off" | "no" | "n":
+            value = False
+        case _:
+            raise ValueError(f"Expected a boolean value for the environment variable '{env_name}', but got '{value}'")
+    return value
+
+
+def get_list_env_var(env_name: str) -> list[str]:
+    """Read an environment variable and return its value as a list of strings.
+
+    The value is expected to be a comma-separated string. Whitespace around
+    each item is stripped, and empty items are ignored.
+
+    Args:
+        env_name (str): name of the environment variable to read.
+
+    Returns:
+        list[str]: list of non-empty strings, or None if the variable is not set or empty.
+    """
+    value = os.environ.get(env_name)
+    if value is None or value.strip() == "":
+        return None
+    return [item.strip() for item in value.split(",") if item.strip()]
+
+
 def _merge_key_recursive(target_dict, source_dict, key):
     if key not in target_dict:
         target_dict[key] = source_dict[key]
@@ -155,6 +198,7 @@ def __new__(cls, *args, **kwargs) -> "Config":
                 "http_permanent_session_lifetime": datetime.timedelta(days=31),
                 "username": "mindsdb",
                 "password": "",
+                "token": None,  # MINDSDB_AUTH_TOKEN
             },
             "logging": {
                 "handlers": {
@@ -199,6 +243,26 @@ def __new__(cls, *args, **kwargs) -> "Config":
                     "host": "0.0.0.0",  # API server binds to all interfaces by default
                     "port": "8000",
                 },
+                "mcp": {
+                    "cors": {
+                        "enabled": True,
+                        "allow_origins": [],
+                        "allow_origin_regex": r"https?://(localhost|127\.0\.0\.1)(:\d+)?",
+                        "allow_headers": ["*"],
+                    },
+                    "rate_limit": {
+                        "enabled": False,
+                        "requests_per_minute": 60,
+                    },
+                    "oauth": {
+                        "enabled": False,  # MINDSDB_MCP_OAUTH_ENABLED
+                        "issuer_url": "",  # MINDSDB_MCP_OAUTH_ISSUER_URL
+                        "client_id": "",  # MINDSDB_MCP_OAUTH_CLIENT_ID
+                        "client_secret": "",  # MINDSDB_MCP_OAUTH_CLIENT_SECRET
+                        "scope": "mcp:tools",  # MINDSDB_MCP_OAUTH_SCOPE
+                    },
+                    "dns_rebinding_protection": False,  # MINDSDB_MCP_DNS_REBINDING_PROTECTION
+                },
             },
             "cache": {"type": "local"},
             "ml_task_queue": {"type": "local"},
@@ -215,6 +279,9 @@ def __new__(cls, *args, **kwargs) -> "Config":
             "data_catalog": {
                 "enabled": False,
             },
+            "data_stream": {
+                "fetch_size": 10000,
+            },
             "byom": {
                 "enabled": False,
             },
@@ -223,6 +290,7 @@ def __new__(cls, *args, **kwargs) -> "Config":
             "knowledge_bases": {
                 "disable_autobatch": False,
                 "disable_pgvector_autobatch": True,
+                "storage": None,
             },
         }
         # endregion
@@ -246,13 +314,17 @@ def prepare_env_config(self) -> None:
         """Collect config values from env vars to self._env_config"""
         self._env_config = {
             "logging": {"handlers": {"console": {}, "file": {}}},
-            "api": {"http": {}},
+            "api": {
+                "http": {},
+                "mcp": {"cors": {}, "rate_limit": {}, "oauth": {}},
+            },
             "auth": {},
             "paths": {},
             "permanent_storage": {},
             "ml_task_queue": {},
             "gui": {},
             "byom": {},
+            "knowledge_bases": {},
         }
 
         # region storage root path
@@ -312,6 +384,10 @@ def prepare_env_config(self) -> None:
         elif http_auth_type != "":
             raise ValueError(f"Wrong value of env var MINDSDB_HTTP_AUTH_TYPE={http_auth_type}")
 
+        mindsdb_auth_token = os.environ.get("MINDSDB_AUTH_TOKEN", "")
+        if mindsdb_auth_token != "":
+            self._env_config["auth"]["token"] = mindsdb_auth_token
+
         # region logging
         if os.environ.get("MINDSDB_LOG_LEVEL", "") != "":
             self._env_config["logging"]["handlers"]["console"]["level"] = os.environ["MINDSDB_LOG_LEVEL"]
@@ -398,20 +474,16 @@ def prepare_env_config(self) -> None:
             if "default_reranking_model" not in self._env_config:
                 self._env_config["default_reranking_model"] = {}
             self._env_config["default_reranking_model"].update(reranker_config)
-        if os.environ.get("MINDSDB_DATA_CATALOG_ENABLED", "").lower() in ("1", "true"):
+        if get_bool_env_var("MINDSDB_DATA_CATALOG_ENABLED") is True:
             self._env_config["data_catalog"] = {"enabled": True}
 
-        if os.environ.get("MINDSDB_NO_STUDIO", "").lower() in ("1", "true"):
+        if get_bool_env_var("MINDSDB_NO_STUDIO") is True:
             self._env_config["gui"]["open_on_start"] = False
             self._env_config["gui"]["autoupdate"] = False
 
-        mindsdb_gui_autoupdate = os.environ.get("MINDSDB_GUI_AUTOUPDATE", "").lower()
-        if mindsdb_gui_autoupdate in ("0", "false"):
-            self._env_config["gui"]["autoupdate"] = False
-        elif mindsdb_gui_autoupdate in ("1", "true"):
-            self._env_config["gui"]["autoupdate"] = True
-        elif mindsdb_gui_autoupdate != "":
-            raise ValueError(f"Wrong value of env var MINDSDB_GUI_AUTOUPDATE={mindsdb_gui_autoupdate}")
+        mindsdb_gui_autoupdate = get_bool_env_var("MINDSDB_GUI_AUTOUPDATE")
+        if mindsdb_gui_autoupdate is not None:
+            self._env_config["gui"]["autoupdate"] = mindsdb_gui_autoupdate
 
         if os.environ.get("MINDSDB_PID_FILE_CONTENT", "") != "":
             try:
@@ -427,6 +499,48 @@ def prepare_env_config(self) -> None:
         elif mindsdb_byom_enabled != "":
             raise ValueError(f"Wrong value of env var MINDSDB_BYOM_ENABLED={mindsdb_byom_enabled}")
 
+        # region MCP config
+        mindsdb_mcp_enabled = get_bool_env_var("MINDSDB_MCP_CORS_ENABLED")
+        if mindsdb_mcp_enabled is not None:
+            self._env_config["api"]["mcp"]["cors"]["enabled"] = mindsdb_mcp_enabled
+        mindsdb_mcp_allow_origins = get_list_env_var("MINDSDB_MCP_ALLOW_ORIGINS")
+        if isinstance(mindsdb_mcp_allow_origins, list):
+            self._env_config["api"]["mcp"]["cors"]["allow_origins"] = mindsdb_mcp_allow_origins
+        mindsdb_mcp_allow_headers = get_list_env_var("MINDSDB_MCP_ALLOW_HEADERS")
+        if isinstance(mindsdb_mcp_allow_headers, list):
+            self._env_config["api"]["mcp"]["cors"]["allow_headers"] = mindsdb_mcp_allow_headers
+        mindsdb_mcp_allow_origin_regex = os.environ.get("MINDSDB_MCP_ALLOW_ORIGIN_REGEXP", "")
+        if mindsdb_mcp_allow_origin_regex != "":
+            self._env_config["api"]["mcp"]["cors"]["allow_origin_regex"] = mindsdb_mcp_allow_origin_regex
+        mindsdb_mcp_rate_limit_enabled = get_bool_env_var("MINDSDB_MCP_RATE_LIMIT_ENABLED")
+        if mindsdb_mcp_rate_limit_enabled is not None:
+            self._env_config["api"]["mcp"]["rate_limit"]["enabled"] = mindsdb_mcp_rate_limit_enabled
+        mindsdb_mcp_rate_limit_rpm = os.environ.get("MINDSDB_MCP_RATE_LIMIT_RPM", "")
+        if mindsdb_mcp_rate_limit_rpm != "":
+            self._env_config["api"]["mcp"]["rate_limit"]["requests_per_minute"] = int(mindsdb_mcp_rate_limit_rpm)
+
+        mindsdb_mcp_oauth_enabled = get_bool_env_var("MINDSDB_MCP_OAUTH_ENABLED")
+        if mindsdb_mcp_oauth_enabled is not None:
+            self._env_config["api"]["mcp"]["oauth"]["enabled"] = mindsdb_mcp_oauth_enabled
+        mindsdb_mcp_oauth_issuer_url = os.environ.get("MINDSDB_MCP_OAUTH_ISSUER_URL", "")
+        if mindsdb_mcp_oauth_issuer_url != "":
+            self._env_config["api"]["mcp"]["oauth"]["issuer_url"] = mindsdb_mcp_oauth_issuer_url
+        mindsdb_mcp_oauth_client_id = os.environ.get("MINDSDB_MCP_OAUTH_CLIENT_ID", "")
+        if mindsdb_mcp_oauth_client_id != "":
+            self._env_config["api"]["mcp"]["oauth"]["client_id"] = mindsdb_mcp_oauth_client_id
+        mindsdb_mcp_oauth_client_secret = os.environ.get("MINDSDB_MCP_OAUTH_CLIENT_SECRET", "")
+        if mindsdb_mcp_oauth_client_secret != "":
+            self._env_config["api"]["mcp"]["oauth"]["client_secret"] = mindsdb_mcp_oauth_client_secret
+        mindsdb_mcp_oauth_scope = os.environ.get("MINDSDB_MCP_OAUTH_SCOPE", "")
+        if mindsdb_mcp_oauth_scope != "":
+            self._env_config["api"]["mcp"]["oauth"]["scope"] = mindsdb_mcp_oauth_scope
+        mindsdb_mcp_dns_rebinding_protection = get_bool_env_var("MINDSDB_MCP_DNS_REBINDING_PROTECTION")
+        if mindsdb_mcp_dns_rebinding_protection is not None:
+            self._env_config["api"]["mcp"]["dns_rebinding_protection"] = mindsdb_mcp_dns_rebinding_protection
+        # endregion
+
+        # Keep env-based KB defaults out of config.auto.json overrides.
+
     def fetch_auto_config(self) -> bool:
         """Load dict readed from config.auto.json to `auto_config`.
         Do it only if `auto_config` was not loaded before or config.auto.json been changed.
@@ -589,6 +703,7 @@ def parse_cmd_args(self) -> None:
                 agent=None,
                 project=None,
                 update_gui=False,
+                mcp_stdio=False,
             )
             return
 
@@ -615,7 +730,7 @@ def parse_cmd_args(self) -> None:
 
         parser.add_argument("--project-name", type=str, default=None, help="MindsDB project name")
         parser.add_argument("--update-gui", action="store_true", default=False, help="Update GUI and exit")
-        parser.add_argument("--load-tokenizer", action="store_true", default=False, help="Preload tokenizer and exit")
+        parser.add_argument("--mcp-stdio", action="store_true", default=False, help="Run MCP with STDIO transport")
 
         self._cmd_args = parser.parse_args()
 
diff --git a/mindsdb/utilities/fs.py b/mindsdb/utilities/fs.py
index 2462960acca..8e77b74d172 100644
--- a/mindsdb/utilities/fs.py
+++ b/mindsdb/utilities/fs.py
@@ -1,4 +1,5 @@
 import os
+import sys
 import json
 import time
 import tempfile
@@ -6,6 +7,9 @@
 from pathlib import Path
 from typing import Generator
 
+import tarfile
+import zipfile
+
 import psutil
 
 from mindsdb.utilities import log
@@ -127,6 +131,70 @@ def clean_unlinked_process_marks() -> list[int]:
     return deleted_pids
 
 
+class PidFileLock:
+    """Cross-platform exclusive file lock context manager.
+    Uses fcntl.flock on Unix and msvcrt.locking on Windows.
+
+    Attributes:
+        _lock_file_path (Path): path to lock file
+        _blocking (bool): if True, waits until the lock becomes available, otherwise raises OSError immediately if lock is held
+        _fh (int): lock file descriptor
+    """
+
+    def __init__(self, lock_file_path: Path, blocking: bool = True):
+        self._lock_file_path = lock_file_path
+        self._blocking = blocking
+        self._fh = None
+
+    def __enter__(self):
+        self._lock_file_path.parent.mkdir(parents=True, exist_ok=True)
+        self._fh = open(self._lock_file_path, "a+")
+        try:
+            if sys.platform == "win32":
+                import msvcrt
+
+                # NOTE if file is locked, LK_LOCK will raise OSError after 10 seconds, LK_NBLCK immediately
+                mode = msvcrt.LK_LOCK if self._blocking else msvcrt.LK_NBLCK
+                self._fh.seek(0)
+                msvcrt.locking(self._fh.fileno(), mode, 1)
+            else:
+                import fcntl
+
+                flags = fcntl.LOCK_EX
+                if not self._blocking:
+                    flags |= fcntl.LOCK_NB
+                fcntl.flock(self._fh.fileno(), flags)
+        except (OSError, IOError):
+            self._fh.close()
+            self._fh = None
+            logger.error(f"Failed to acquire lock on {self._lock_file_path}")
+            raise
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._fh is None:
+            return False
+        try:
+            if sys.platform == "win32":
+                import msvcrt
+
+                self._fh.seek(0)
+                msvcrt.locking(self._fh.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                import fcntl
+
+                fcntl.flock(self._fh.fileno(), fcntl.LOCK_UN)
+        except (OSError, IOError):
+            pass
+        finally:
+            try:
+                self._fh.close()
+            except (OSError, IOError):
+                pass
+            self._fh = None
+        return False
+
+
 def create_pid_file(config):
     """
     Create mindsdb process pid file. Check if previous process exists and is running
@@ -140,48 +208,49 @@ def create_pid_file(config):
     p = get_tmp_dir()
     p.mkdir(parents=True, exist_ok=True)
     pid_file = p.joinpath("pid")
-    if pid_file.exists():
-        # if process exists raise exception
-        pid_file_data_str = pid_file.read_text().strip()
-        pid = None
-        try:
-            pid_file_data = json.loads(pid_file_data_str)
-            if isinstance(pid_file_data, dict):
-                pid = pid_file_data.get("pid")
-            else:
-                pid = pid_file_data
-        except json.JSONDecodeError:
-            # is it just pid number (old approach)?
-            try:
-                pid = int(pid_file_data_str)
-            except Exception:
-                pass
-            logger.warning(f"Found existing PID file {pid_file} but it is not a valid JSON, removing")
+    lock_file = p.joinpath("pid.lock")
 
-        if pid is not None:
+    with PidFileLock(lock_file):
+        if pid_file.exists():
+            pid_file_data_str = pid_file.read_text().strip()
+            pid = None
             try:
-                psutil.Process(int(pid))
-                raise Exception(f"Found PID file with existing process: {pid} {pid_file}")
-            except (psutil.Error, ValueError):
-                pass
-            logger.warning(f"Found existing PID file {pid_file}({pid}), removing")
-
-        pid_file.unlink(missing_ok=True)
-
-    pid_file_content = config["pid_file_content"]
-    if pid_file_content is None or len(pid_file_content) == 0:
-        pid_file_data_str = str(os.getpid())
-    else:
-        pid_file_data = {"pid": os.getpid()}
-        for key, value in pid_file_content.items():
-            value_path = value.split(".")
-            value_obj = config
-            for path_part in value_path:
-                value_obj = value_obj.get(path_part) if value_obj else None
-            pid_file_data[key] = value_obj
+                pid_file_data = json.loads(pid_file_data_str)
+                if isinstance(pid_file_data, dict):
+                    pid = pid_file_data.get("pid")
+                else:
+                    pid = pid_file_data
+            except json.JSONDecodeError:
+                try:
+                    pid = int(pid_file_data_str)
+                except Exception:
+                    pass
+                logger.warning(f"Found existing PID file {pid_file} but it is not a valid JSON, removing")
+
+            if pid is not None:
+                try:
+                    psutil.Process(int(pid))
+                    raise Exception(f"Found PID file with existing process: {pid} {pid_file}")
+                except (psutil.Error, ValueError):
+                    pass
+                logger.warning(f"Found existing PID file {pid_file}({pid}), removing")
+
+            pid_file.unlink(missing_ok=True)
+
+        pid_file_content = config["pid_file_content"]
+        if pid_file_content is None or len(pid_file_content) == 0:
+            pid_file_data_str = str(os.getpid())
+        else:
+            pid_file_data = {"pid": os.getpid()}
+            for key, value in pid_file_content.items():
+                value_path = value.split(".")
+                value_obj = config
+                for path_part in value_path:
+                    value_obj = value_obj.get(path_part) if value_obj else None
+                pid_file_data[key] = value_obj
 
-        pid_file_data_str = json.dumps(pid_file_data)
-    pid_file.write_text(pid_file_data_str)
+            pid_file_data_str = json.dumps(pid_file_data)
+        pid_file.write_text(pid_file_data_str)
 
 
 def delete_pid_file():
@@ -193,27 +262,29 @@ def delete_pid_file():
         return
 
     pid_file = get_tmp_dir().joinpath("pid")
+    lock_file = get_tmp_dir().joinpath("pid.lock")
 
-    if not pid_file.exists():
-        return
+    with PidFileLock(lock_file):
+        if not pid_file.exists():
+            return
 
-    pid_file_data_str = pid_file.read_text().strip()
-    pid = None
-    try:
-        pid_file_data = json.loads(pid_file_data_str)
-        if isinstance(pid_file_data, dict):
-            pid = pid_file_data.get("pid")
-        else:
-            # It's a simple number (old format or pid_file_content=None format)
-            pid = pid_file_data
-    except json.JSONDecodeError:
-        logger.warning(f"Found existing PID file {pid_file} but it is not a valid JSON")
+        pid_file_data_str = pid_file.read_text().strip()
+        pid = None
+        try:
+            pid_file_data = json.loads(pid_file_data_str)
+            if isinstance(pid_file_data, dict):
+                pid = pid_file_data.get("pid")
+            else:
+                # It's a simple number (old format or pid_file_content=None format)
+                pid = pid_file_data
+        except json.JSONDecodeError:
+            logger.warning(f"Found existing PID file {pid_file} but it is not a valid JSON")
 
-    if pid is not None and str(pid) != str(os.getpid()):
-        logger.warning(f"Process id in PID file ({pid_file}) doesn't match mindsdb pid")
-        return
+        if pid is not None and str(pid) != str(os.getpid()):
+            logger.warning(f"Process id in PID file ({pid_file}) doesn't match mindsdb pid")
+            return
 
-    pid_file.unlink(missing_ok=True)
+        pid_file.unlink(missing_ok=True)
 
 
 def __is_within_directory(directory, target):
@@ -223,15 +294,24 @@ def __is_within_directory(directory, target):
     return prefix == abs_directory
 
 
-def safe_extract(tarfile, path=".", members=None, *, numeric_owner=False):
-    # for py >= 3.12
-    if hasattr(tarfile, "data_filter"):
-        tarfile.extractall(path, members=members, numeric_owner=numeric_owner, filter="data")
+def safe_extract(archivefile, path=".", members=None, *, numeric_owner=False):
+    if isinstance(archivefile, zipfile.ZipFile):
+        for member in archivefile.namelist():
+            member_path = os.path.join(path, member)
+            if not __is_within_directory(path, member_path):
+                raise Exception("Attempted Path Traversal in Zip File")
+        archivefile.extractall(path, members)
         return
 
-    # for py < 3.12
-    for member in tarfile.getmembers():
-        member_path = os.path.join(path, member.name)
-        if not __is_within_directory(path, member_path):
-            raise Exception("Attempted Path Traversal in Tar File")
-    tarfile.extractall(path, members=members, numeric_owner=numeric_owner)
+    if isinstance(archivefile, tarfile.TarFile):
+        # for py >= 3.12
+        if hasattr(archivefile, "data_filter"):
+            archivefile.extractall(path, members=members, numeric_owner=numeric_owner, filter="data")
+            return
+
+        # for py < 3.12
+        for member in archivefile.getmembers():
+            member_path = os.path.join(path, member.name)
+            if not __is_within_directory(path, member_path):
+                raise Exception("Attempted Path Traversal in Tar File")
+        archivefile.extractall(path, members=members, numeric_owner=numeric_owner)
diff --git a/mindsdb/utilities/langfuse.py b/mindsdb/utilities/langfuse.py
index def4ec98c7e..92320c48d5e 100644
--- a/mindsdb/utilities/langfuse.py
+++ b/mindsdb/utilities/langfuse.py
@@ -5,8 +5,8 @@
 from mindsdb.utilities import log
 
 if TYPE_CHECKING:
-    from langfuse.callback import CallbackHandler
-    from langfuse.client import StatefulSpanClient
+    from langfuse._client.span import LangfuseSpan
+    from langfuse.langchain import CallbackHandler
 
 logger = log.getLogger(__name__)
 
@@ -111,6 +111,7 @@ def __init__(
             public_key=public_key,
             secret_key=secret_key,
             host=host,
+            environment=environment,
             release=release,
             debug=debug,
             timeout=timeout,
@@ -145,13 +146,14 @@ def setup_trace(
         self.set_tags(tags)
 
         try:
-            self.trace = self.client.trace(
-                name=name, input=input, metadata=self.metadata, tags=self.tags, user_id=user_id, session_id=session_id
-            )
+            # SDK v3+: root observation is a span; trace attributes are set via update_trace.
+            self.trace = self.client.start_span(name=name, input=input, metadata=self.metadata)
+            self.trace.update_trace(tags=self.tags, user_id=user_id, session_id=session_id)
         except Exception:
-            logger.exception(f"Something went wrong while processing Langfuse trace {self.trace.id}:")
+            logger.exception("Something went wrong while creating Langfuse trace")
+            return
 
-        logger.info(f"Langfuse trace configured with ID: {self.trace.id}")
+        logger.info(f"Langfuse trace configured with ID: {self.trace.trace_id}")
 
     def get_trace_id(self) -> typing.Optional[str]:
         """
@@ -166,9 +168,9 @@ def get_trace_id(self) -> typing.Optional[str]:
             logger.debug("Langfuse trace is not setup.")
             return ""
 
-        return self.trace.id
+        return self.trace.trace_id
 
-    def start_span(self, name: str, input: typing.Optional[typing.Any] = None) -> typing.Optional["StatefulSpanClient"]:
+    def start_span(self, name: str, input: typing.Optional[typing.Any] = None) -> typing.Optional["LangfuseSpan"]:
         """
         Create span. If Langfuse is disabled, nothing will be done.
 
@@ -181,9 +183,9 @@ def start_span(self, name: str, input: typing.Optional[typing.Any] = None) -> ty
             logger.debug("Langfuse is disabled.")
             return None
 
-        return self.trace.span(name=name, input=input)
+        return self.trace.start_span(name=name, input=input)
 
-    def end_span_stream(self, span: typing.Optional["StatefulSpanClient"] = None) -> None:
+    def end_span_stream(self, span: typing.Optional["LangfuseSpan"] = None) -> None:
         """
         End span. If Langfuse is disabled, nothing will happen.
         Args:
@@ -195,10 +197,10 @@ def end_span_stream(self, span: typing.Optional["StatefulSpanClient"] = None) ->
             return
 
         span.end()
-        self.trace.update()
+        self.client.flush()
 
     def end_span(
-        self, span: typing.Optional["StatefulSpanClient"] = None, output: typing.Optional[typing.Any] = None
+        self, span: typing.Optional["LangfuseSpan"] = None, output: typing.Optional[typing.Any] = None
     ) -> None:
         """
         End trace. If Langfuse is disabled, nothing will be done.
@@ -216,8 +218,10 @@ def end_span(
             logger.debug("Langfuse span is not created.")
             return
 
-        span.end(output=output)
-        self.trace.update(output=output)
+        if output is not None:
+            span.update(output=output)
+        span.end()
+        self.trace.update_trace(output=output)
 
         metadata = self.metadata or {}
 
@@ -225,9 +229,9 @@ def end_span(
             # Ensure all batched traces are sent before fetching.
             self.client.flush()
             metadata["tool_usage"] = self._get_tool_usage()
-            self.trace.update(metadata=metadata)
+            self.trace.update_trace(metadata=metadata)
         except Exception:
-            logger.exception(f"Something went wrong while processing Langfuse trace {self.trace.id}:")
+            logger.exception(f"Something went wrong while processing Langfuse trace {self.trace.trace_id}:")
 
     def get_langchain_handler(self) -> typing.Optional["CallbackHandler"]:
         """
@@ -238,7 +242,13 @@ def get_langchain_handler(self) -> typing.Optional["CallbackHandler"]:
             logger.debug("Langfuse is disabled.")
             return None
 
-        return self.trace.get_langchain_handler()
+        try:
+            from langfuse.langchain import CallbackHandler
+        except ImportError:
+            logger.debug("langfuse.langchain CallbackHandler is not available (install langchain extra if needed).")
+            return None
+
+        return CallbackHandler(public_key=self.public_key)
 
     def set_metadata(self, custom_metadata: dict = None) -> None:
         """
@@ -267,8 +277,8 @@ def _get_tool_usage(self) -> typing.Dict:
         tool_usage = {}
 
         try:
-            fetched_trace = self.client.get_trace(self.trace.id)
-            steps = [s.name for s in fetched_trace.observations]
+            fetched_trace = self.client.api.trace.get(self.trace.trace_id)
+            steps = [s.name for s in fetched_trace.observations if s.name]
             for step in steps:
                 if "AgentAction" in step:
                     tool_name = step.split("-")[1]
@@ -276,8 +286,8 @@ def _get_tool_usage(self) -> typing.Dict:
                         tool_usage[tool_name] = 0
                     tool_usage[tool_name] += 1
         except TraceNotFoundError:
-            logger.warning(f"Langfuse trace {self.trace.id} not found")
+            logger.warning(f"Langfuse trace {self.trace.trace_id} not found")
         except Exception:
-            logger.exception(f"Something went wrong while processing Langfuse trace {self.trace.id}:")
+            logger.exception(f"Something went wrong while processing Langfuse trace {self.trace.trace_id}:")
 
         return tool_usage
diff --git a/mindsdb/utilities/log.py b/mindsdb/utilities/log.py
index 8c76ad9d4ea..2ae311a61da 100644
--- a/mindsdb/utilities/log.py
+++ b/mindsdb/utilities/log.py
@@ -4,10 +4,15 @@
 import logging
 import threading
 from typing import Any
+import warnings
 from logging.config import dictConfig
 
 from mindsdb.utilities.config import config as app_config
 
+# Suppress Pydantic warnings for third-party libraries
+# TODO: Work on a better solution to this
+warnings.filterwarnings("ignore", message="Field.*has conflict with protected namespace.*", category=UserWarning)
+
 
 logging_initialized = False
 
@@ -205,6 +210,7 @@ def get_handlers_config(process_name: str) -> dict:
             "class": "mindsdb.utilities.log.StreamSanitizingHandler",
             "formatter": console_handler_config.get("formatter", "default"),
             "level": console_handler_config_level,
+            "stream": console_handler_config.get("stream", "ext://sys.stderr"),
         }
 
     file_handler_config = app_config["logging"]["handlers"]["file"]
diff --git a/mindsdb/utilities/types/__init__.py b/mindsdb/utilities/types/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/mindsdb/utilities/types/column.py b/mindsdb/utilities/types/column.py
new file mode 100644
index 00000000000..e8d258468d3
--- /dev/null
+++ b/mindsdb/utilities/types/column.py
@@ -0,0 +1,30 @@
+from dataclasses import dataclass, field, MISSING
+
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
+
+
+@dataclass(kw_only=True, slots=True)
+class Column:
+    name: str = field(default=MISSING)
+    alias: str | None = None
+    table_name: str | None = None
+    table_alias: str | None = None
+    type: MYSQL_DATA_TYPE | None = None
+    database: str | None = None
+    flags: dict = None
+    charset: str | None = None
+    original_type: str | None = None
+    dtype: str | None = None
+
+    def __post_init__(self):
+        if self.alias is None:
+            self.alias = self.name
+        if self.table_alias is None:
+            self.table_alias = self.table_name
+
+    def get_hash_name(self, prefix):
+        table_name = self.table_name if self.table_alias is None else self.table_alias
+        name = self.name if self.alias is None else self.alias
+
+        name = f"{prefix}_{table_name}_{name}"
+        return name
diff --git a/mindsdb/utilities/utils.py b/mindsdb/utilities/utils.py
index 3c9bd09162c..160b03fe79c 100644
--- a/mindsdb/utilities/utils.py
+++ b/mindsdb/utilities/utils.py
@@ -2,6 +2,8 @@
 import re
 import typing
 
+from pydantic import BaseModel, ValidationError
+
 
 def parse_csv_attributes(csv_attributes: typing.Optional[str] = "") -> typing.Dict[str, str]:
     """
@@ -32,3 +34,24 @@ def parse_csv_attributes(csv_attributes: typing.Optional[str] = "") -> typing.Di
         raise ValueError(f"Failed to parse csv_attributes='{csv_attributes}': {e}") from e
 
     return attributes
+
+
+def validate_pydantic_params(params: dict, schema: type[BaseModel], subject: str):
+    # check names and types
+    try:
+        schema.model_validate(params)
+    except ValidationError as e:
+        problems = []
+        for error in e.errors():
+            parameter = ".".join([str(i) for i in error["loc"]])
+            param_type = error["type"]
+            if param_type == "extra_forbidden":
+                msg = f"Parameter '{parameter}' is not allowed"
+            else:
+                msg = f"Error in '{parameter}' (type: {param_type}): {error['msg']}. Input: {repr(error['input'])}"
+            problems.append(msg)
+
+        msg = "\n".join(problems)
+        if len(problems) > 1:
+            msg = "\n" + msg
+        raise ValueError(f"Problem with {subject} parameters: {msg}") from e
diff --git a/requirements/requirements-agents.txt b/requirements/requirements-agents.txt
index 83b60d9f496..e96657bb724 100644
--- a/requirements/requirements-agents.txt
+++ b/requirements/requirements-agents.txt
@@ -1,19 +1,14 @@
-openai<3.0.0,>=2.9.0
-
-langchain-community==0.3.27
-langchain-core==0.3.77
-langchain-experimental==0.3.4
-
+openai<3.0.0,>=2.11.0
 
 # When using agents, some LLMs may require the 'transformers' library (like Ollama):
-transformers >= 4.42.4
+transformers==5.5.0
 
 # Required for KB
 mindsdb-evaluator == 0.0.21
-litellm==1.63.14
-mcp~=1.10.1 # Required for MCP server
+mcp~=1.26.0 # Required for MCP server
 
 # A2A requirements
 httpx==0.28.1
 jwcrypto==1.5.6
-typing-extensions==4.14.1
+# fastmcp (via pydantic-ai) requires typing-extensions>=4.15.0 (py-key-value-aio chain)
+typing-extensions>=4.15.0,<5
diff --git a/requirements/requirements-kb.txt b/requirements/requirements-kb.txt
index eb5adbfaefb..334e7c0f352 100644
--- a/requirements/requirements-kb.txt
+++ b/requirements/requirements-kb.txt
@@ -1,4 +1,2 @@
 lxml==5.3.0 # Is this transitive dependency?
-pgvector==0.3.6 # Required for knowledge bases
-langchain-core==0.3.77
-litellm==1.63.14
\ No newline at end of file
+faiss-cpu==1.13.2 # default vector storage
diff --git a/requirements/requirements-langfuse.txt b/requirements/requirements-langfuse.txt
index fffecd7da86..7cd73e32d75 100644
--- a/requirements/requirements-langfuse.txt
+++ b/requirements/requirements-langfuse.txt
@@ -1 +1 @@
-langfuse==2.53.3  # Latest as of November 4, 2024
\ No newline at end of file
+langfuse==3.2.5
\ No newline at end of file
diff --git a/requirements/requirements-opentelemetry.txt b/requirements/requirements-opentelemetry.txt
index eae7c0601c4..0b262f9b35a 100644
--- a/requirements/requirements-opentelemetry.txt
+++ b/requirements/requirements-opentelemetry.txt
@@ -1,6 +1,6 @@
-opentelemetry-api==1.27.0
-opentelemetry-sdk==1.27.0
-opentelemetry-exporter-otlp==1.27.0
-opentelemetry-instrumentation-requests==0.48b0
-opentelemetry-instrumentation-flask==0.48b0
-opentelemetry-distro==0.48b0
\ No newline at end of file
+opentelemetry-api==1.39.1
+opentelemetry-sdk==1.39.1
+opentelemetry-exporter-otlp==1.39.1
+opentelemetry-instrumentation-requests==0.60b1
+opentelemetry-instrumentation-flask==0.60b1
+opentelemetry-distro==0.60b1
\ No newline at end of file
diff --git a/requirements/requirements-test.txt b/requirements/requirements-test.txt
index 58f887f4881..fcfc1730626 100644
--- a/requirements/requirements-test.txt
+++ b/requirements/requirements-test.txt
@@ -20,4 +20,5 @@ mysql-connector-python==9.1.0
 walrus==0.9.3
 pymongo == 4.8.0
 pytest-json-report==1.5.0
-appdirs >= 1.0.0
\ No newline at end of file
+appdirs >= 1.0.0
+pgvector==0.3.6 # Required for knowledge bases tests
diff --git a/requirements/requirements.txt b/requirements/requirements.txt
index ee0a73eabb5..759f05a0bcd 100644
--- a/requirements/requirements.txt
+++ b/requirements/requirements.txt
@@ -1,16 +1,16 @@
 packaging
-flask == 3.0.3
-werkzeug == 3.0.6
+flask == 3.1.3
+werkzeug == 3.1.6
 flask-restx >= 1.3.0, < 2.0.0
-pandas == 2.2.3
-python-multipart == 0.0.20
-cryptography>=35.0
+pandas==2.3.1
+python-multipart == 0.0.22
+cryptography>=46.0.5
 psycopg[binary]
 psutil~=7.0
 sqlalchemy >= 2.0.0, < 3.0.0
 psycopg2-binary  # This is required for using sqlalchemy with postgres
 alembic >= 1.3.3
-redis >=5.0.0, < 6.0.0
+redis==6.4.0
 walrus==0.9.3
 flask-compress >= 1.0.0
 appdirs >= 1.0.0
@@ -18,7 +18,7 @@ mindsdb-sql-parser ~= 0.13.8
 pydantic == 2.12.5
 duckdb == 1.3.0; sys_platform == "win32"
 duckdb ~= 1.3.2; sys_platform != "win32"
-requests == 2.32.4
+requests == 2.33.0
 dateparser==1.2.0
 dill == 0.3.6
 numpy ~= 2.0
@@ -35,18 +35,19 @@ a2wsgi ~= 1.10.10  # WSGI wrapper for flask+starlette
 starlette>=0.49.1
 sse-starlette==2.3.3
 pydantic_core>=2.33.2
-pyjwt==2.10.1
+pyjwt==2.12.0
 # files reading
-pymupdf==1.25.2
+pymupdf==1.27.2
 filetype
 charset-normalizer
 openpyxl # used by pandas to read txt and xlsx files
-aipdf==0.0.7.0
+xlrd>=2.0.1 # used by pandas to read legacy .xls files
+aipdf==0.0.7.2
 pyarrow<=19.0.0 # used by pandas to read feather files in Files handler
-orjson==3.11.3
+orjson==3.11.6
 
-mind-castle >= 0.4.9
-pydantic-ai>=0.0.14 # Required for Pydantic AI agents
+mind-castle==0.5.0
+pydantic-ai==1.77.0 # Required for Pydantic AI agents
 
 bs4 # for rag HTMLDocumentLoader
 urllib3>=2.6.3 # not directly required, pinned by Snyk to avoid a vulnerability
diff --git a/scripts/run_unit_tests.sh b/scripts/run_unit_tests.sh
index 28d3dc1c33c..275fc07f517 100755
--- a/scripts/run_unit_tests.sh
+++ b/scripts/run_unit_tests.sh
@@ -217,10 +217,6 @@ for handler in "${HANDLERS_TO_INSTALL[@]}"; do
         -r requirements/requirements-test.txt \
         "${HANDLER_EXTRAS[@]}"
 
-    # Install onnxruntime for ChromaDB
-    echo "Installing onnxruntime..."
-    uv pip install --force-reinstall onnxruntime==1.20.1
-
     # Clone parser tests
     PARSER_VERSION=$(uv pip show mindsdb_sql_parser | grep Version | cut -d ' ' -f 2)
     if [[ ! -d "parser_tests" ]]; then
diff --git a/tests/scripts/check_requirements.py b/tests/scripts/check_requirements.py
index 800a7fa1d4c..f3bcc6382dc 100644
--- a/tests/scripts/check_requirements.py
+++ b/tests/scripts/check_requirements.py
@@ -104,10 +104,13 @@ def get_requirements_with_DEP002(path):
         "langchain-experimental",
         "lxml",
         "openpyxl",
+        "xlrd",
         "onnxruntime",
         "litellm",
         "numba",  # required in a few files for the hierarchicalforecast. Otherwise, uv may install an old version.
         "urllib3",  # pinned by Snyk to avoid a vulnerability
+        "faiss-cpu",
+        "pyopenssl",
     ],
 }
 
@@ -135,7 +138,7 @@ def get_requirements_with_DEP002(path):
 
 HUGGINGFACE_DEP002_IGNORE_HANDLER_DEPS = ["torch"]
 
-RAG_DEP002_IGNORE_HANDLER_DEPS = ["sentence-transformers", "faiss-cpu"]
+RAG_DEP002_IGNORE_HANDLER_DEPS = ["sentence-transformers"]
 
 SOLR_DEP002_IGNORE_HANDLER_DEPS = ["sqlalchemy-solr"]
 
@@ -143,6 +146,8 @@ def get_requirements_with_DEP002(path):
 
 CHROMADB_EP002_IGNORE_HANDLER_DEPS = ["onnxruntime"]
 
+FRESHDESK_EP002_IGNORE_HANDLER_DEPS = ["python-freshdesk"]
+
 # The `pyarrow` package is used only if it is installed.
 # The handler can work without it.
 SNOWFLAKE_DEP003_IGNORE_HANDLER_DEPS = ["pyarrow"]
@@ -158,6 +163,7 @@ def get_requirements_with_DEP002(path):
         + SOLR_DEP002_IGNORE_HANDLER_DEPS
         + OPENAI_DEP002_IGNORE_HANDLER_DEPS
         + CHROMADB_EP002_IGNORE_HANDLER_DEPS
+        + FRESHDESK_EP002_IGNORE_HANDLER_DEPS
     )
 )
 
@@ -175,6 +181,7 @@ def get_requirements_with_DEP002(path):
         "IfxPyDbi",
         "ingres_sa_dialect",
         "pyodbc",
+        "freshdesk",
     ],  # 'tests' is the mindsdb tests folder in the repo root, 'pyarrow' used in snowflake handler
     "DEP003": DEP003_IGNORE_HANDLER_DEPS,
 }
@@ -252,6 +259,7 @@ def get_requirements_with_DEP002(path):
     "python-dotenv": ["dotenv"],
     "pyjwt": ["jwt"],
     "sklearn": ["scikit-learn"],
+    "ag2": ["autogen"],
 }
 
 # We use this to exit with a non-zero status code if any check fails
diff --git a/tests/unit/api/http/agents_test.py b/tests/unit/api/http/agents_test.py
index a6253132384..bd2532bcd78 100644
--- a/tests/unit/api/http/agents_test.py
+++ b/tests/unit/api/http/agents_test.py
@@ -27,14 +27,13 @@ def test_prepare(client):
 @pytest.mark.deprecated(
     "MindsDB models are no longer used with agents. However, Minds still uses models, so this test is kept for now"
 )
-def test_post_agent_depreciated(client):
+@patch("mindsdb.interfaces.agents.agents_controller.check_agent_llm")
+def test_post_agent_depreciated(check_agent_llm, client):
     create_request = {
         "agent": {
             "name": "test_post_agent_depreciated",
-            "model_name": "test_model",
-            "params": {"k1": "v1"},
-            "provider": "mindsdb",
-            "skills": ["test_skill"],
+            "model": {"provider": "openai", "model_name": "test_model"},
+            "params": {"timeout": 10},
         }
     }
 
@@ -45,9 +44,8 @@ def test_post_agent_depreciated(client):
 
     expected_agent = {
         "name": "test_post_agent_depreciated",
-        "model_name": "test_model",
-        "provider": "mindsdb",
-        "params": {"k1": "v1"},
+        "model": {"provider": "openai", "model_name": "test_model"},
+        "params": {"timeout": 10},
         "id": created_agent["id"],
         "project_id": created_agent["project_id"],
         "created_at": created_agent["created_at"],
@@ -57,7 +55,9 @@ def test_post_agent_depreciated(client):
     assert created_agent == expected_agent
 
 
-def test_post_agent(client):
+@patch("mindsdb.interfaces.agents.agents_controller.check_agent_llm")
+@patch("mindsdb.interfaces.agents.agents_controller.check_agent_data")
+def test_post_agent(check_agent_data, check_agent_llm, client):
     create_request = {
         "agent": {
             "name": "TEST_post_agent",
@@ -161,7 +161,9 @@ def test_get_agents_project_not_found(client):
     assert get_response.status_code == HTTPStatus.NOT_FOUND
 
 
-def test_get_agent(client):
+@patch("mindsdb.interfaces.agents.agents_controller.check_agent_llm")
+@patch("mindsdb.interfaces.agents.agents_controller.check_agent_data")
+def test_get_agent(check_agent_data, check_agent_llm, client):
     create_request = {
         "agent": {
             "name": "test_get_agent",
@@ -236,13 +238,13 @@ def test_get_agent_project_not_found(client):
 @pytest.mark.deprecated(
     "MindsDB models are no longer used with agents. However, Minds still uses models, so this test is kept for now"
 )
-def test_put_agent_update_depreciated(client):
+@patch("mindsdb.interfaces.agents.agents_controller.check_agent_llm")
+def test_put_agent_update_depreciated(check_agent_llm, client):
     create_request = {
         "agent": {
             "name": "test_put_agent_update_depreciated",
-            "model_name": "test_model",
-            "params": {"k1": "v1", "k2": "v2"},
-            "provider": "mindsdb",
+            "model": {"provider": "openai", "model_name": "test_model"},
+            "params": {"timeout": 10},
         }
     }
 
@@ -251,7 +253,7 @@ def test_put_agent_update_depreciated(client):
 
     update_request = {
         "agent": {
-            "params": {"k1": "v1.1", "k2": None, "k3": "v3"},
+            "params": {"timeout": 20},
         }
     }
 
@@ -262,9 +264,8 @@ def test_put_agent_update_depreciated(client):
 
     expected_agent = {
         "name": "test_put_agent_update_depreciated",
-        "model_name": "test_model",
-        "params": {"k1": "v1.1", "k3": "v3"},
-        "provider": "mindsdb",
+        "model": {"provider": "openai", "model_name": "test_model"},
+        "params": {"timeout": 20},
         "id": updated_agent["id"],
         "project_id": updated_agent["project_id"],
         "created_at": updated_agent["created_at"],
@@ -277,7 +278,9 @@ def test_put_agent_update_depreciated(client):
 @pytest.mark.deprecated(
     "MindsDB models are no longer used with agents. However, Minds still uses models, so this test is kept for now"
 )
-def test_put_agent_update(client):
+@patch("mindsdb.interfaces.agents.agents_controller.check_agent_llm")
+@patch("mindsdb.interfaces.agents.agents_controller.check_agent_data")
+def test_put_agent_update(check_agent_data, check_agent_llm, client):
     create_request = {
         "agent": {
             "name": "test_put_agent_update",
@@ -292,7 +295,7 @@ def test_put_agent_update(client):
 
     update_request = {
         "agent": {
-            "params": {"k1": "v1.1", "k2": None, "k3": "v3"},
+            "params": {"timeout": 5},
             "data": {
                 "tables": ["example_db.customers", "example_db.orders"],
                 "knowledge_bases": ["example_kb"],
@@ -307,7 +310,7 @@ def test_put_agent_update(client):
 
     expected_agent = {
         "name": "test_put_agent_update",
-        "params": {"k1": "v1.1", "k3": "v3"},
+        "params": {"timeout": 5},
         "id": updated_agent["id"],
         "project_id": updated_agent["project_id"],
         "created_at": updated_agent["created_at"],
@@ -356,7 +359,9 @@ def test_put_agent_no_agent(client):
 #     assert '404' in response.status
 
 
-def test_delete_agent(client):
+@patch("mindsdb.interfaces.agents.agents_controller.check_agent_llm")
+@patch("mindsdb.interfaces.agents.agents_controller.check_agent_data")
+def test_delete_agent(check_agent_data, check_agent_llm, client):
     create_request = {
         "agent": {
             "name": "test_delete_agent",
@@ -385,13 +390,14 @@ def test_delete_agent_not_found(client):
     assert delete_response.status_code == HTTPStatus.NOT_FOUND
 
 
-def test_agent_completions(client):
+@patch("mindsdb.interfaces.agents.agents_controller.check_agent_llm")
+def test_agent_completions(check_agent_llm, client):
     create_request = {
         "agent": {
             "name": "test_agent",
             "model_name": "test_model",
             "provider": "mindsdb",
-            "params": {"prompt_template": "Test message!", "user_column": "content"},
+            "params": {"prompt_template": "Test message!"},
         }
     }
 
diff --git a/tests/unit/api/http/config_test.py b/tests/unit/api/http/config_test.py
new file mode 100644
index 00000000000..672d7d31cd0
--- /dev/null
+++ b/tests/unit/api/http/config_test.py
@@ -0,0 +1,9 @@
+def test_get_config_returns_knowledge_bases_storage(client):
+    response = client.get("/api/config/")
+
+    assert response.status_code == 200
+    payload = response.get_json()
+    assert "knowledge_bases" in payload
+    assert "storage" in payload["knowledge_bases"]
+    assert "available_vector_engines" in payload["knowledge_bases"]
+    assert "pgvector_enabled" in payload["knowledge_bases"]
diff --git a/tests/unit/api/http/files_test.py b/tests/unit/api/http/files_test.py
index 7fd56c878ac..c2eecce5e81 100644
--- a/tests/unit/api/http/files_test.py
+++ b/tests/unit/api/http/files_test.py
@@ -1,5 +1,6 @@
 import io
 import os.path
+import os
 from http import HTTPStatus
 
 
@@ -172,22 +173,27 @@ def test_archive_file_with_extension_upload(client):
     assert "File name cannot contain extension." in data["detail"]
 
 
-def test_put_file_with_path_in_filename_multipart(client):
-    """Test uploading a file with path traversal in the filename via multipart form data"""
-    file = io.BytesIO(b"Hello, World!")
+def test_zipfile_traversal(client):
+    """Test uploading a zip archive with path traversal filenames"""
+    import zipfile
+    import io
 
-    data = {
-        "file": (file, "../test.txt"),
-        "source_type": "file",
-    }
+    # Create a zip file in memory with a symlink
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr("../../../../etc/passwd", "malicious content")
+    zip_buffer.seek(0)
+    data = {"file": (zip_buffer, "archive.zip")}
     response = client.put(
-        "/api/files/testfile",
+        "/api/files/archive",
         data=data,
         content_type="multipart/form-data",
         follow_redirects=True,
     )
     # Should fail due to path validation (ValueError is raised)
     assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+    data = response.get_json()
+    assert "Attempted Path Traversal in Zip File" in data["detail"]
 
 
 def test_put_file_with_invalid_parameters_multipart(client):
diff --git a/tests/unit/api/http/knowledge_bases_test.py b/tests/unit/api/http/knowledge_bases_test.py
index b4bd4f3488d..4ccfccfe7a7 100644
--- a/tests/unit/api/http/knowledge_bases_test.py
+++ b/tests/unit/api/http/knowledge_bases_test.py
@@ -3,17 +3,17 @@
 from unittest.mock import patch
 
 
-@patch("mindsdb.integrations.handlers.chromadb_handler.chromadb_handler.ChromaDBHandler")
-@patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-def test_update_kb_embeddings(mock_embedding, chroma, client):
+@patch("mindsdb.integrations.handlers.duckdb_faiss_handler.duckdb_faiss_handler.DuckDBFaissHandler")
+@patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+def test_update_kb_embeddings(mock_embedding, handler, client):
     # for test of embeddings
-    mock_embedding().data = [{"embedding": [0.1, 0.2]}]
+    mock_embedding().embeddings.return_value = [{"embedding": [0.1, 0.2]}]
 
     integration_data = {
         "database": {
             "name": "kb_vector_db",
-            "engine": "chromadb",
-            "parameters": {"persist_directory": "kb_vector_db"},
+            "engine": "duckdb_faiss",
+            "parameters": {},
         }
     }
     response = client.post("/api/databases", json=integration_data, follow_redirects=True)
@@ -54,5 +54,5 @@ def test_update_kb_embeddings(mock_embedding, chroma, client):
     )
 
     assert update_response.status_code == HTTPStatus.OK
-    kwargs = mock_embedding.call_args_list[0][1]
+    kwargs = mock_embedding.call_args_list[0][0][0]
     assert kwargs["api_key"] == "embed-key-2"
diff --git a/tests/unit/api/http/test_sql_query.py b/tests/unit/api/http/test_sql_query.py
new file mode 100644
index 00000000000..b40096ecdcc
--- /dev/null
+++ b/tests/unit/api/http/test_sql_query.py
@@ -0,0 +1,145 @@
+"""
+Tests for POST /sql/query endpoint with different response_format values:
+1. DEFAULT (None) - returns JSON response
+2. SSE ("sse") - returns Server-Sent Events stream
+3. JSONLINES ("jsonlines") - returns JSON Lines stream
+"""
+
+import json
+from http import HTTPStatus
+from unittest.mock import patch, MagicMock
+
+import pandas as pd
+
+from mindsdb.api.executor.data_types.sql_answer import SQLAnswer
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+from mindsdb.api.executor.sql_query.result_set import ResultSet
+from mindsdb.utilities.types.column import Column
+
+
+def create_mock_sql_answer():
+    """Create a mock SQLAnswer with table data for testing."""
+    columns = [
+        Column(name="id", alias="id"),
+        Column(name="name", alias="name"),
+        Column(name="value", alias="value"),
+    ]
+
+    df = pd.DataFrame(
+        [
+            [1, "test1", 100],
+            [2, "test2", 200],
+            [3, "test3", 300],
+        ]
+    )
+
+    result_set = ResultSet(columns=columns, df=df)
+
+    return SQLAnswer(
+        resp_type=RESPONSE_TYPE.TABLE,
+        result_set=result_set,
+    )
+
+
+def check_response(response_data: dict):
+    # Check response structure for default format
+    assert response_data["type"] == "table"
+    assert "data" in response_data
+    assert "column_names" in response_data
+    assert "context" in response_data
+
+    # Check data content
+    assert response_data["column_names"] == ["id", "name", "value"]
+    assert len(response_data["data"]) == 3
+    assert response_data["data"][0] == [1, "test1", 100]
+    assert response_data["data"][1] == [2, "test2", 200]
+    assert response_data["data"][2] == [3, "test3", 300]
+
+
+def setup_mock_proxy(mock_proxy_class):
+    """Configure mock proxy with default behavior."""
+    mock_proxy = MagicMock()
+    mock_proxy_class.return_value = mock_proxy
+    mock_proxy.process_query.return_value = create_mock_sql_answer()
+    mock_proxy.get_context.return_value = {}
+    return mock_proxy
+
+
+class TestSQLQueryResponseFormat:
+    @patch("mindsdb.api.http.namespaces.sql.FakeMysqlProxy")
+    def test_query_default_format(self, mock_proxy_class, client):
+        """Test POST /sql/query with default response format (no response_format parameter)."""
+        setup_mock_proxy(mock_proxy_class)
+
+        response = client.post(
+            "/api/sql/query",
+            json={"query": "SELECT * FROM table"},
+        )
+
+        assert response.status_code == HTTPStatus.OK
+        response_data = response.json
+        check_response(response_data)
+
+    @patch("mindsdb.api.http.namespaces.sql.FakeMysqlProxy")
+    def test_query_sse_format(self, mock_proxy_class, client):
+        """Test POST /sql/query with SSE response format (response_format="sse")."""
+        setup_mock_proxy(mock_proxy_class)
+
+        response = client.post(
+            "/api/sql/query",
+            json={
+                "query": "SELECT * FROM table",
+                "response_format": "sse",
+            },
+        )
+
+        assert response.status_code == HTTPStatus.OK
+        assert "text/event-stream" in response.content_type
+
+        # Parse SSE response and build unified response dict
+        response_text = response.get_data(as_text=True)
+        lines = [line.replace("data: ", "") for line in response_text.split("\n") if line.startswith("data: ")]
+
+        assert len(lines) > 1
+        header = json.loads(lines[0])
+        data_rows = json.loads(lines[1])
+
+        response_data = {
+            "type": header["type"],
+            "column_names": header["column_names"],
+            "data": data_rows,
+            "context": {},
+        }
+        check_response(response_data)
+
+    @patch("mindsdb.api.http.namespaces.sql.FakeMysqlProxy")
+    def test_query_jsonlines_format(self, mock_proxy_class, client):
+        """Test POST /sql/query with JSONLINES response format (response_format="jsonlines")."""
+        setup_mock_proxy(mock_proxy_class)
+
+        response = client.post(
+            "/api/sql/query",
+            json={
+                "query": "SELECT * FROM table",
+                "response_format": "jsonlines",
+            },
+        )
+
+        assert response.status_code == HTTPStatus.OK
+        assert response.content_type == "application/jsonlines"
+
+        # Parse JSONLINES response and build unified response dict
+        response_text = response.get_data(as_text=True)
+        lines = [line for line in response_text.split("\n") if line.strip()]
+
+        assert len(lines) > 1
+        header = json.loads(lines[0])
+        data_rows = json.loads(lines[1])
+
+        response_data = {
+            "type": header["type"],
+            "column_names": header["column_names"],
+            "data": data_rows,
+            "context": {},
+        }
+        check_response(response_data)
diff --git a/tests/unit/api/mcp/__init__.py b/tests/unit/api/mcp/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/unit/api/mcp/test_completions.py b/tests/unit/api/mcp/test_completions.py
new file mode 100644
index 00000000000..ab03ecff049
--- /dev/null
+++ b/tests/unit/api/mcp/test_completions.py
@@ -0,0 +1,135 @@
+"""
+Unit tests for the MCP completion handler (mindsdb/api/mcp/completions.py).
+"""
+
+import asyncio
+from unittest.mock import MagicMock, patch
+
+from mcp.types import PromptReference, ResourceTemplateReference
+from mcp.shared.memory import create_connected_server_and_client_session
+
+from mindsdb.api.mcp.mcp_instance import mcp
+
+# ---------------------------------------------------------------------------
+# Patch targets
+# ---------------------------------------------------------------------------
+
+_PATCH_GET_DB_NAMES = "mindsdb.api.mcp.completions._get_database_names"
+_PATCH_CTX = "mindsdb.api.mcp.completions.ctx"
+_PATCH_SESSION = "mindsdb.api.mcp.completions.SessionController"
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def _complete(ref, argument: dict, context_arguments: dict | None = None) -> list[str]:
+    """Run a completion request and return the list of completion values."""
+
+    async def _inner():
+        async with create_connected_server_and_client_session(mcp) as client:
+            result = await client.complete(
+                ref=ref,
+                argument=argument,
+                context_arguments=context_arguments,
+            )
+            return result.completion.values
+
+    return _run(_inner())
+
+
+_PROMPT_REF = PromptReference(type="ref/prompt", name="sample_table")
+_RESOURCE_REF = ResourceTemplateReference(
+    type="ref/resource",
+    uri="schema://databases/{database_name}/tables",
+)
+
+
+def _make_table_mock(name: str) -> MagicMock:
+    t = MagicMock()
+    t.TABLE_NAME = name
+    return t
+
+
+class TestDatabaseNameCompletion:
+    def test_returns_matching_databases(self):
+        with patch(_PATCH_GET_DB_NAMES, return_value=["pg_prod", "pg_staging", "mysql_db"]):
+            values = _complete(_PROMPT_REF, {"name": "database_name", "value": "pg"})
+
+        assert values == ["pg_prod", "pg_staging"]
+
+    def test_prefix_filters_case_sensitively(self):
+        with patch(_PATCH_GET_DB_NAMES, return_value=["Postgres", "postgres"]):
+            values = _complete(_PROMPT_REF, {"name": "database_name", "value": "post"})
+
+        assert values == ["postgres"]
+
+    def test_empty_prefix_returns_all_databases(self):
+        db_names = ["pg", "mysql", "mongo"]
+        with patch(_PATCH_GET_DB_NAMES, return_value=db_names):
+            values = _complete(_PROMPT_REF, {"name": "database_name", "value": ""})
+
+        assert values == db_names
+
+    def test_no_match_returns_empty_list(self):
+        with patch(_PATCH_GET_DB_NAMES, return_value=["pg", "mysql"]):
+            values = _complete(_PROMPT_REF, {"name": "database_name", "value": "oracle"})
+
+        assert values == []
+
+
+class TestTableNameCompletion:
+    def test_returns_matching_tables(self):
+        with patch(_PATCH_SESSION) as SC:
+            SC.return_value.datahub.get.return_value.get_tables.return_value = [
+                _make_table_mock("orders"),
+                _make_table_mock("order_items"),
+                _make_table_mock("users"),
+            ]
+
+            # match 2/3
+            values = _complete(
+                _RESOURCE_REF,
+                {"name": "table_name", "value": "ord"},
+                context_arguments={"database_name": "pg"},
+            )
+
+            SC.return_value.datahub.get.assert_called_with("pg")
+            assert values == ["orders", "order_items"]
+
+            # match all
+            values = _complete(
+                _RESOURCE_REF,
+                {"name": "table_name", "value": ""},
+                context_arguments={"database_name": "pg"},
+            )
+
+            assert values == ["orders", "order_items", "users"]
+
+            # match 0
+            values = _complete(
+                _RESOURCE_REF,
+                {"name": "table_name", "value": "qwerty"},
+                context_arguments={"database_name": "pg"},
+            )
+
+            assert values == []
+
+    def test_missing_database_name_context_returns_empty(self):
+        """When database_name is not in context_arguments, return empty."""
+        with patch(_PATCH_SESSION):
+            values = _complete(
+                _RESOURCE_REF,
+                {"name": "table_name", "value": "ord"},
+                context_arguments=None,
+            )
+
+        assert values == []
+
+    def test_unknown_argument_name_returns_empty(self):
+        values = _complete(_PROMPT_REF, {"name": "unknown_param", "value": "foo"})
+        assert values == []
diff --git a/tests/unit/api/mcp/test_prompts.py b/tests/unit/api/mcp/test_prompts.py
new file mode 100644
index 00000000000..2e7ea7b5d60
--- /dev/null
+++ b/tests/unit/api/mcp/test_prompts.py
@@ -0,0 +1,45 @@
+"""
+Unit tests for MCP prompts (mindsdb/api/mcp/prompts/*).
+
+mcp.get_prompt() is async; tests run it with asyncio.run().
+"""
+
+import json
+import asyncio
+
+from mindsdb.api.mcp.mcp_instance import mcp
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def _get_sample_table_prompt(database_name: str, table_name: str):
+    """Call sample_table prompt and return the GetPromptResult."""
+    return _run(mcp.get_prompt("sample_table", {"database_name": database_name, "table_name": table_name}))
+
+
+def _get_first_message_text(prompt: object) -> str:
+    """Return the text content of the first message."""
+    raw = prompt.messages[0].content.text
+    # FastMCP serialises the TextContent to JSON inside the PromptMessage
+    return json.loads(raw)["text"]
+
+
+class TestPrompt:
+    def test_sample_table_exists(self):
+        # sample_table exists and has description
+        prompts = _run(mcp.list_prompts())
+        prompt = next(p for p in prompts if p.name == "sample_table")
+        assert prompt.description  # non-empty
+
+    def test_sample_table_content(self):
+        # test content of the prompt
+        result = _get_sample_table_prompt("MyDB", "mytable")
+        assert len(result.messages) == 1
+        assert result.messages[0].role == "user"
+        assert result.messages[0].content.type == "text"
+
+        text = _get_first_message_text(result)
+        assert "`MyDB`.`mytable`" in text
+        assert "limit 5" in text.lower()
diff --git a/tests/unit/api/mcp/test_query_tool.py b/tests/unit/api/mcp/test_query_tool.py
new file mode 100644
index 00000000000..bd4d0bcd430
--- /dev/null
+++ b/tests/unit/api/mcp/test_query_tool.py
@@ -0,0 +1,129 @@
+"""
+Unit tests for the MCP tools (mindsdb/api/mcp/tools/*).
+"""
+
+import asyncio
+import json
+from unittest.mock import patch
+
+
+_PATCH_PROXY = "mindsdb.api.mcp.tools.query.FakeMysqlProxy"
+
+
+def _run(coro):
+    """Run an async coroutine synchronously."""
+    return asyncio.run(coro)
+
+
+def _call_tool(sql: str, context=None):
+    """Call the MCP query tool synchronously and return parsed JSON."""
+    args = {"query": sql}
+    if context is not None:
+        args["context"] = context
+
+    from mindsdb.api.mcp.mcp_instance import mcp
+
+    content, _ = _run(mcp.call_tool("query", args))
+    return json.loads(content[0].text)
+
+
+def _make_proxy_ok(mock_proxy_cls, affected_rows=0):
+    """Configure mock proxy to return an OK response."""
+    mock_proxy_cls.return_value.process_query.return_value.dump_http_response.return_value = {
+        "type": "ok",
+        "affected_rows": affected_rows,
+    }
+    return mock_proxy_cls.return_value
+
+
+def _make_proxy_table(mock_proxy_cls, column_names, data):
+    """Configure mock proxy to return a table response."""
+    mock_proxy_cls.return_value.process_query.return_value.dump_http_response.return_value = {
+        "type": "table",
+        "column_names": column_names,
+        "data": data,
+    }
+    return mock_proxy_cls.return_value
+
+
+def _make_proxy_error(mock_proxy_cls, error_message, error_code=0):
+    """Configure mock proxy to return an error response."""
+    mock_proxy_cls.return_value.process_query.return_value.dump_http_response.return_value = {
+        "type": "error",
+        "error_code": error_code,
+        "error_message": error_message,
+    }
+    return mock_proxy_cls.return_value
+
+
+class TestResponseTypes:
+    def test_select_returns_table_type(self):
+        expected_data = [[1, "alice"], [2, "bob"]]
+        columns_list = ["id", "name"]
+        with patch(_PATCH_PROXY) as MockProxy:
+            _make_proxy_table(MockProxy, columns_list, expected_data)
+            result = _call_tool("SELECT * FROM mydb.users")
+
+        assert result["type"] == "table"
+        assert result["column_names"] == columns_list
+        assert result["data"] == expected_data
+
+    def test_select_empty_result(self):
+        columns_list = ["id", "name"]
+        with patch(_PATCH_PROXY) as MockProxy:
+            _make_proxy_table(MockProxy, columns_list, [])
+            result = _call_tool("SELECT * FROM mydb.users WHERE 1=0")
+
+        assert result["type"] == "table"
+        assert result["column_names"] == columns_list
+        assert result["data"] == []
+
+    def test_insert_returns_ok_type(self):
+        with patch(_PATCH_PROXY) as MockProxy:
+            _make_proxy_ok(MockProxy, affected_rows=1)
+            result = _call_tool("INSERT INTO mydb.t (id) VALUES (1)")
+
+        assert result["type"] == "ok"
+        assert result["affected_rows"] == 1
+
+    def test_proxy_error_response_returns_error_type(self):
+        error_message = "Table 'x' doesn't exist"
+        with patch(_PATCH_PROXY) as MockProxy:
+            _make_proxy_error(MockProxy, error_message, error_code=123)
+            result = _call_tool("SELECT * FROM mydb.x")
+
+        assert result["type"] == "error"
+        assert result["error_message"] == error_message
+        assert result["error_code"] == 123
+
+    def test_exception_in_process_query_returns_error_type(self):
+        error_message = "connection refused"
+        with patch(_PATCH_PROXY) as MockProxy:
+            MockProxy.return_value.process_query.side_effect = Exception(error_message)
+            result = _call_tool("SELECT 1")
+
+        assert result["type"] == "error"
+        assert result["error_message"] == error_message
+
+
+class TestContextParameter:
+    def test_context_is_passed_to_set_context(self):
+        with patch(_PATCH_PROXY) as MockProxy:
+            proxy = _make_proxy_ok(MockProxy)
+            _call_tool("SELECT 1", context={"db": "my_postgres"})
+
+        proxy.set_context.assert_called_once_with({"db": "my_postgres"})
+
+    def test_omitted_context_defaults_to_empty_dict(self):
+        with patch(_PATCH_PROXY) as MockProxy:
+            proxy = _make_proxy_ok(MockProxy)
+            _call_tool("SELECT 1")  # no context argument
+
+        proxy.set_context.assert_called_once_with({})
+
+    def test_explicit_none_context_defaults_to_empty_dict(self):
+        with patch(_PATCH_PROXY) as MockProxy:
+            proxy = _make_proxy_ok(MockProxy)
+            _call_tool("SELECT 1", context=None)
+
+        proxy.set_context.assert_called_once_with({})
diff --git a/tests/unit/api/mcp/test_resources.py b/tests/unit/api/mcp/test_resources.py
new file mode 100644
index 00000000000..6bac3891875
--- /dev/null
+++ b/tests/unit/api/mcp/test_resources.py
@@ -0,0 +1,177 @@
+"""
+Unit tests for MCP resources (mindsdb/api/mcp/resources/*)
+"""
+
+import asyncio
+import json
+from unittest.mock import MagicMock, patch
+
+import pandas as pd
+
+from mindsdb.integrations.libs.response import TableResponse as HandlerTableResponse
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+
+
+_PATCH_SESSION = "mindsdb.api.mcp.resources.schema.SessionController"
+_PATCH_TABLE_RESPONSE = "mindsdb.api.mcp.resources.schema.TableResponse"
+_PATCH_RESPONSE_TYPE = "mindsdb.api.mcp.resources.schema.RESPONSE_TYPE"
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def _read(uri: str) -> list:
+    """Read a resource and return parsed JSON payload."""
+    from mindsdb.api.mcp.mcp_instance import mcp
+
+    contents = list(_run(mcp.read_resource(uri)))
+    return json.loads(contents[0].content)
+
+
+def _make_table_mock(name: str, table_type: str = "BASE TABLE", schema: str = "public") -> MagicMock:
+    t = MagicMock()
+    t.TABLE_NAME = name
+    t.TABLE_TYPE = table_type
+    t.TABLE_SCHEMA = schema
+    return t
+
+
+def _make_columns_table_response(rows: list[dict]) -> MagicMock:
+    """Build a mock HandlerTableResponse with COLUMNS_TABLE type."""
+    tr = MagicMock(spec=HandlerTableResponse)
+    tr.type = RESPONSE_TYPE.COLUMNS_TABLE
+    tr.fetchall.return_value = pd.DataFrame(rows)
+    return tr
+
+
+def _make_kb(name, project, metadata_cols=None, content_cols=None, id_col="id"):
+    return {
+        "name": name,
+        "project": project,
+        "metadata_columns": metadata_cols or [],
+        "content_columns": content_cols or ["body"],
+        "id_column": id_col,
+    }
+
+
+class TestListDatabases:
+    def test_returns_only_data_type_databases(self):
+        from mindsdb.api.mcp.mcp_instance import mcp
+
+        with patch(_PATCH_SESSION) as SC:
+            SC.return_value.database_controller.get_list.return_value = [
+                {"name": "pg_prod", "type": "data"},
+                {"name": "mindsdb", "type": "project"},
+                {"name": "mysql_db", "type": "data"},
+            ]
+
+            result = list(_run(mcp.read_resource("schema://databases")))
+
+        assert len(result) == 1
+        assert json.loads(result[0].content) == ["pg_prod", "mysql_db"]
+        assert result[0].mime_type == "application/json"
+
+    def test_filters_out_all_non_data_types(self):
+        with patch(_PATCH_SESSION) as SC:
+            SC.return_value.database_controller.get_list.return_value = [
+                {"name": "mindsdb", "type": "project"},
+                {"name": "files", "type": "files"},
+            ]
+            result = _read("schema://databases")
+
+        assert result == []
+
+
+class TestDbTables:
+    def test_returns_table_names(self):
+        with patch(_PATCH_SESSION) as SC:
+            SC.return_value.datahub.get.return_value.get_tables.return_value = [
+                _make_table_mock("orders"),
+                _make_table_mock("users"),
+            ]
+            result = _read("schema://databases/mydb/tables")
+
+            SC.return_value.datahub.get.assert_called_once_with("mydb")
+
+        names = [t["TABLE_NAME"] for t in result]
+        assert names == ["orders", "users"]
+        assert set(result[0].keys()) == {"TABLE_NAME", "TABLE_TYPE", "TABLE_SCHEMA"}
+
+    def test_returns_table_type_and_schema(self):
+        with patch(_PATCH_SESSION) as SC:
+            SC.return_value.datahub.get.return_value.get_tables.return_value = [
+                _make_table_mock("orders", table_type="VIEW", schema="myschema"),
+            ]
+            result = _read("schema://databases/mydb/tables")
+
+        assert result[0]["TABLE_TYPE"] == "VIEW"
+        assert result[0]["TABLE_SCHEMA"] == "myschema"
+
+    def test_empty_database_returns_empty_list(self):
+        with patch(_PATCH_SESSION) as SC:
+            SC.return_value.datahub.get.return_value.get_tables.return_value = []
+            result = _read("schema://databases/emptydb/tables")
+
+        assert result == []
+
+
+class TestDbTableColumns:
+    def test_returns_column_names_and_types(self):
+        rows = [
+            {"COLUMN_NAME": "id", "MYSQL_DATA_TYPE": "int"},
+            {"COLUMN_NAME": "email", "MYSQL_DATA_TYPE": "varchar(255)"},
+        ]
+        with (
+            patch(_PATCH_SESSION) as SC,
+            patch(_PATCH_TABLE_RESPONSE, HandlerTableResponse),
+            patch(_PATCH_RESPONSE_TYPE, RESPONSE_TYPE),
+        ):
+            SC.return_value.integration_controller.get_data_handler.return_value.get_columns.return_value = (
+                _make_columns_table_response(rows)
+            )
+
+            result = _read("schema://databases/mydb/tables/orders/columns")
+            SC.return_value.integration_controller.get_data_handler.assert_called_once_with("mydb")
+            SC.return_value.integration_controller.get_data_handler.return_value.get_columns.assert_called_once_with(
+                "orders"
+            )
+
+        assert result[0] == {"COLUMN_NAME": "id", "MYSQL_DATA_TYPE": "int"}
+        assert result[1] == {"COLUMN_NAME": "email", "MYSQL_DATA_TYPE": "varchar(255)"}
+
+
+class TestListKnowledgeBases:
+    def test_returns_knowledge_bases_from_all_projects(self):
+        with patch(_PATCH_SESSION) as SC:
+            SC.return_value.datahub.get_projects_names.return_value = ["mindsdb", "my_project"]
+            SC.return_value.kb_controller.list.side_effect = [
+                [_make_kb("kb1", "mindsdb")],
+                [_make_kb("kb2", "my_project")],
+            ]
+            result = _read("schema://knowledge_bases")
+
+        assert len(result) == 2
+        assert result[0]["name"] == "kb1"
+        assert result[1]["name"] == "kb2"
+
+    def test_returns_correct_kb_fields(self):
+        kb = _make_kb(
+            "docs_kb",
+            "mindsdb",
+            metadata_cols=["source", "date"],
+            content_cols=["body"],
+            id_col="doc_id",
+        )
+        with patch(_PATCH_SESSION) as SC:
+            SC.return_value.datahub.get_projects_names.return_value = ["mindsdb"]
+            SC.return_value.kb_controller.list.return_value = [kb]
+            result = _read("schema://knowledge_bases")
+
+        assert result[0] == {
+            "name": "docs_kb",
+            "project": "mindsdb",
+            "metadata_columns": ["source", "date"],
+            "content_columns": ["body"],
+            "id_column": "doc_id",
+        }
diff --git a/tests/unit/executor/test_agent.py b/tests/unit/executor/test_agent.py
index 88306a748f9..a41d36f0a6c 100644
--- a/tests/unit/executor/test_agent.py
+++ b/tests/unit/executor/test_agent.py
@@ -1,15 +1,15 @@
-import time
 import os
 import json
 
 from unittest.mock import patch, AsyncMock
 
+from sqlalchemy.orm.attributes import flag_modified
 import pandas as pd
 import pytest
 import sys
 from openai.types.chat import ChatCompletion
 from tests.unit.executor_test_base import BaseExecutorDummyML
-from tests.unit.executor.test_knowledge_base import set_litellm_embedding
+from tests.unit.executor.test_knowledge_base import set_embedding
 
 
 def action_response(type="final_query", sql="", text=""):
@@ -18,16 +18,19 @@ def action_response(type="final_query", sql="", text=""):
     return json.dumps({"sql_query": sql, "type": type, "text": text, "short_description": "a tool"})
 
 
-def set_openai_completion(mock_openai, llm_response):
+def set_openai_completion(mock_openai, llm_response, add_planning=True):
     if isinstance(llm_response, str):
         llm_responses = [
             action_response(sql=f"select '{llm_response}' as answer"),
         ]
+    elif not isinstance(llm_response, list):
+        llm_responses = [llm_response]
     else:
         llm_responses = llm_response
 
-    # always add plan response
-    llm_responses.insert(0, '{"plan":"my plan is ...", "estimated_steps":3}')
+    if add_planning:
+        # add plan response
+        llm_responses.insert(0, '{"plan":"my plan is ...", "estimated_steps":3}')
 
     mock_openai.agent_calls = []
     calls = []
@@ -104,84 +107,10 @@ def setup_method(self):
 
         config["knowledge_bases"]["disable_autobatch"] = True
 
-    @pytest.mark.slow
-    def unused_test_mindsdb_provider(self):
-        # pydantic agent doesn't support using mindsdb model
-        from mindsdb.api.executor.exceptions import ExecutorException
-
-        agent_response = "how can I help you"
-        # model
-        self.run_sql(
-            f"""
-                CREATE model base_model
-                PREDICT output
-                using
-                  column='question',
-                  output='{agent_response}',
-                  engine='dummy_ml',
-                  join_learn_process=true
-            """
-        )
-
-        self.run_sql("CREATE ML_ENGINE langchain FROM langchain")
-
-        agent_params = """
-            USING
-                provider='mindsdb',
-                model = "base_model", -- <
-                prompt_template="Answer the user input in a helpful way"
-        """
-        self.run_sql(f"""
-            CREATE AGENT my_agent {agent_params}
-        """)
-        with pytest.raises(ExecutorException):
-            self.run_sql(f"""
-                CREATE AGENT my_agent {agent_params}
-            """)
-        self.run_sql(f"""
-            CREATE AGENT IF NOT EXISTS my_agent {agent_params}
-        """)
-
-        ret = self.run_sql("select * from my_agent where question = 'hi'")
-
-        assert agent_response in ret.answer[0]
-
-    @pytest.mark.skipif(
-        sys.platform in ["darwin", "win32"], reason="Mocking doesn't work on Windows or macOS for some reason"
-    )
-    @patch("openai.OpenAI")
-    def unused_test_openai_provider_with_model(self, mock_openai):
-        # pydantic agent doesn't support using mindsdb model
-
-        agent_response = "how can I assist you today?"
-        set_openai_completion(mock_openai, agent_response)
-
-        self.run_sql("CREATE ML_ENGINE langchain FROM langchain")
-
-        self.run_sql("""
-            CREATE MODEL lang_model
-                PREDICT answer USING
-            engine = "langchain",
-            model = "gpt-3.5-turbo",
-            openai_api_key='--',
-            prompt_template="Answer the user input in a helpful way";
-         """)
-
-        time.sleep(5)
-
-        self.run_sql("""
-            CREATE AGENT my_agent
-            USING
-              model='lang_model'
-         """)
-        ret = self.run_sql("select * from my_agent where question = 'hi'")
-
-        assert agent_response in ret.answer[0]
-
     @patch("pydantic_ai.providers.openai.AsyncOpenAI")
     def test_openai_provider(self, mock_openai):
-        agent_response = "how can I assist you today?"
-        set_openai_completion(mock_openai, agent_response)
+        # test response
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
 
         self.run_sql("""
             CREATE AGENT my_agent
@@ -193,6 +122,10 @@ def test_openai_provider(self, mock_openai):
              },
              prompt_template="Answer the user input in a helpful way"
          """)
+
+        agent_response = "how can I assist you today?"
+        set_openai_completion(mock_openai, agent_response)
+
         ret = self.run_sql("select * from my_agent where question = 'hi'")
 
         # check model params
@@ -252,10 +185,8 @@ def config_get_side_effect(key, default=None):
 
         mock_config_get.side_effect = config_get_side_effect
 
-        agent_response = "how can I assist you today?"
-        set_openai_completion(mock_openai, agent_response)
-
         # Create an agent with only provider specified - should use default LLM params
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
             CREATE AGENT default_params_agent
             USING
@@ -266,6 +197,8 @@ def config_get_side_effect(key, default=None):
              },
              prompt_template="Answer the user input in a helpful way"
          """)
+        agent_response = "how can I assist you today?"
+        set_openai_completion(mock_openai, agent_response)
 
         # Check that the agent was created with the default parameters
         agent_info = self.run_sql("SELECT * FROM information_schema.agents WHERE name = 'default_params_agent'")
@@ -273,7 +206,7 @@ def config_get_side_effect(key, default=None):
         # Verify the agent has the user-specified parameters but not default parameters
         agent_params = json.loads(agent_info["PARAMS"].iloc[0])
         assert agent_params.get("prompt_template") == "Answer the user input in a helpful way"
-        assert agent_params["model"]["model_name"] == "gpt-3"
+        assert "gpt-3" in agent_info["MODEL"][0]
 
         # Default parameters should NOT be stored in the database
         # They will be applied at runtime via get_agent_llm_params
@@ -291,19 +224,18 @@ def config_get_side_effect(key, default=None):
 
         # --- Test that agent creation works with minimal syntax using default_llm config ---
 
-        mock_openai.reset_mock()
-        agent_response = "how can I assist you today?"
-        set_openai_completion(mock_openai, agent_response)
-
         # Create an agent with minimal syntax - should use all default LLM params
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
             CREATE AGENT minimal_syntax_agent
             USING
-              data = {
-                "tables": ['test.table1', 'test.table2']
-              }
+              data = { }
          """)
 
+        mock_openai.reset_mock()
+        agent_response = "how can I assist you today?"
+        set_openai_completion(mock_openai, agent_response)
+
         ret = self.run_sql("select * from minimal_syntax_agent where question = 'hi'")
         assert agent_response in ret.answer[0]
 
@@ -314,18 +246,21 @@ def config_get_side_effect(key, default=None):
     @pytest.mark.skipif(sys.platform == "darwin", reason="Fails on macOS")
     @patch("pydantic_ai.providers.openai.AsyncOpenAI")
     def test_agent_stream(self, mock_openai):
-        agent_response = "how can I assist you today?"
-        set_openai_completion(mock_openai, agent_response)
-
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
             CREATE AGENT my_agent
             USING
-             provider='openai',
-             model = "gpt-3.5-turbo",
-             openai_api_key='--',
+             model={
+                "model_name": "gpt-3.5-turbo",
+                "provider": "openai",
+                "api_key": "--"
+             },            
              prompt_template="Answer the user input in a helpful way"
          """)
 
+        agent_response = "how can I assist you today?"
+        set_openai_completion(mock_openai, agent_response)
+
         agents_controller = self.command_executor.session.agents_controller
         agent = agents_controller.get_agent("my_agent")
 
@@ -340,11 +275,7 @@ def test_agent_stream(self, mock_openai):
     def _create_kb_storage(self, kb_name):
         self.run_sql(f"""
           create database db_{kb_name} 
-           with 
-           engine='chromadb',
-           PARAMETERS = {{
-               'persist_directory': '{kb_name}'
-           }}
+           with engine='duckdb_faiss'
         """)
         return f"db_{kb_name}.default_collection"
 
@@ -355,10 +286,10 @@ def _drop_kb_storage(self, vector_table_name):
 
         self.run_sql(f"drop database {db_name}")
 
-    @patch("litellm.embedding")
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
     @patch("pydantic_ai.providers.openai.AsyncOpenAI")
-    def test_agent_retrieval(self, mock_openai, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    def test_agent_retrieval(self, mock_openai, mock_embedding):
+        set_embedding(mock_embedding)
 
         vector_table_name = self._create_kb_storage("kb_review")
         self.run_sql(f"""
@@ -374,16 +305,18 @@ def test_agent_retrieval(self, mock_openai, mock_litellm_embedding):
 
         os.environ["OPENAI_API_KEY"] = "--"
 
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
           create agent retrieve_agent
            using
-          model='gpt-3.5-turbo',
-          provider='openai',
+          model={
+            "model_name": "gpt-3.5-turbo",
+            "provider": "openai"
+          },  
           prompt_template='Answer the user input in a helpful way using tools',
           data = {
                 "knowledge_bases": ["kb_review"]
-          },
-          mode='retrieval'
+          }
         """)
 
         agent_response = "the answer is yes"
@@ -417,10 +350,12 @@ def test_agent_retrieval(self, mock_openai, mock_litellm_embedding):
         self._drop_kb_storage(vector_table_name)
 
     # should not be possible to drop demo agent
-    def test_drop_demo_agent(self):
+    @patch("pydantic_ai.providers.openai.AsyncOpenAI")
+    def test_drop_demo_agent(self, mock_openai):
         """should not be possible to drop demo agent"""
         from mindsdb.api.executor.exceptions import ExecutorException
 
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
             CREATE AGENT my_demo_agent
             USING
@@ -429,37 +364,49 @@ def test_drop_demo_agent(self):
                     'model_name': "gpt-3.5-turbo",
                     'api_key': '-key-'
                 },
-                prompt_template="--",
-                is_demo=true;
+                prompt_template="--"
          """)
+
+        # mark as demo in db
+        agent = self.db.Agents.query.filter_by(name="my_demo_agent").first()
+        agent.params["is_demo"] = True
+        flag_modified(agent, "params")
+        self.db.session.commit()
         with pytest.raises(ExecutorException):
-            self.run_sql("drop agent my_agent")
+            self.run_sql("drop agent my_demo_agent")
 
     @patch("pydantic_ai.providers.openai.AsyncOpenAI")
     def test_agent_default_prompt_template(self, mock_openai):
         """Test that agents work correctly with default prompt templates in different modes"""
-        agent_response = "default prompt template response"
-        set_openai_completion(mock_openai, agent_response)
 
         # Test non-retrieval mode with no prompt_template (should use default)
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
             CREATE AGENT default_prompt_agent
             USING
-                provider='openai',
-                model = "gpt-3.5-turbo",
-                openai_api_key='--'
+                model={
+                  "model_name": "gpt-3.5-turbo",
+                  "provider": "openai",
+                  "api_key": "--"
+                }
          """)
+
+        agent_response = "default prompt template response"
+        set_openai_completion(mock_openai, agent_response)
+
         ret = self.run_sql("select * from default_prompt_agent where question = 'test question'")
         assert agent_response in ret.answer[0]
 
         # Test retrieval mode with no prompt_template (should use default retrieval template)
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
             CREATE AGENT default_retrieval_agent
             USING
-                provider='openai',
-                model = "gpt-3.5-turbo",
-                openai_api_key='--',
-                mode='retrieval'
+                model={
+                   "model_name": "gpt-3.5-turbo",
+                   "provider": "openai",
+                   "api_key": "--"
+                }
          """)
 
         mock_openai.reset_mock()
@@ -468,9 +415,9 @@ def test_agent_default_prompt_template(self, mock_openai):
         assert agent_response in ret.answer[0]
 
     @patch("pydantic_ai.providers.openai.AsyncOpenAI")
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_agent_permissions(self, mock_litellm_embedding, mock_openai):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_agent_permissions(self, mock_embedding, mock_openai):
+        set_embedding(mock_embedding)
 
         vector_table_name = self._create_kb_storage("kb_show")
 
@@ -495,11 +442,14 @@ def test_agent_permissions(self, mock_litellm_embedding, mock_openai):
             select id, planet_name content from files.show1
         """)
 
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
             CREATE AGENT my_agent
             USING
-              model = "gpt-3.5-turbo",
-              openai_api_key='--',
+              model={
+                "model_name": "gpt-3.5-turbo",
+                "api_key": '--'
+              },
               data = {
                 "knowledge_bases": ["kb_show*"],
                 "tables": ["files.show*"]
@@ -585,9 +535,9 @@ def test_agent_permissions(self, mock_litellm_embedding, mock_openai):
         self._drop_kb_storage(vector_table_name)
 
     @patch("pydantic_ai.providers.openai.AsyncOpenAI")
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_agent_new_syntax(self, mock_litellm_embedding, mock_openai):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_agent_new_syntax(self, mock_embedding, mock_openai):
+        set_embedding(mock_embedding)
         vector_table_name = self._create_kb_storage("kb")
         df = get_dataset_planets()
         # create 2 files and KBs
@@ -605,6 +555,7 @@ def test_agent_new_syntax(self, mock_litellm_embedding, mock_openai):
                 select id, planet_name content from files.file{i} where id != 1000
             """)
 
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
             CREATE AGENT my_agent
             USING
@@ -657,6 +608,7 @@ def test_agent_new_syntax(self, mock_litellm_embedding, mock_openai):
         assert "important user instruction №42" in mock_openai.agent_calls[0]
 
         # --- ALTER AGENT ---
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
             ALTER AGENT my_agent
             USING
@@ -713,9 +665,9 @@ def test_agent_new_syntax(self, mock_litellm_embedding, mock_openai):
         self._drop_kb_storage(vector_table_name)
 
     @patch("pydantic_ai.providers.openai.AsyncOpenAI")
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_agent_accept_wrong_quoting(self, mock_litellm_embedding, mock_openai):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_agent_accept_wrong_quoting(self, mock_embedding, mock_openai):
+        set_embedding(mock_embedding)
         vector_table_name = self._create_kb_storage("kb1")
         self.run_sql(f"""
             create knowledge base kb1
@@ -727,11 +679,14 @@ def test_agent_accept_wrong_quoting(self, mock_litellm_embedding, mock_openai):
 
         self.save_file("file1", df)
 
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
             CREATE AGENT my_agent
             USING
-              model = "gpt-3.5-turbo",
-              openai_api_key='--',
+              model={
+                "model_name": "gpt-3.5-turbo",
+                "api_key": '--'
+              },
               data = {
                  "knowledge_bases": ["kb1"],
                  "tables": ["files.file1", "files.file2.*"]
@@ -765,11 +720,14 @@ def test_3_part_table(self, mock_pg, mock_openai):
         df = get_dataset_planets()
         self.set_handler(mock_pg, name="pg", tables={"planets": df}, schema="public")
 
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql("""
             CREATE AGENT my_agent
             USING
-              model = "gpt-3.5-turbo",
-              openai_api_key='--',
+              model={
+                "model_name": "gpt-3.5-turbo",
+                "api_key": '--'
+              },
               data = {
                  "tables": ["pg.public.*"] 
               }
@@ -792,19 +750,23 @@ def test_3_part_table(self, mock_pg, mock_openai):
         assert "Moon" in mock_openai.agent_calls[3]
         assert "Moon" in mock_openai.agent_calls[4]
 
+    @patch("pydantic_ai.providers.openai.AsyncOpenAI")
     @patch("mindsdb.interfaces.agents.pydantic_ai_agent.PydanticAIAgent._get_completion_stream")
-    def test_agent_query_param_override(self, mock_get_completion):
+    def test_agent_query_param_override(self, mock_get_completion, mock_openai):
         """
         Test that agent parameters can be overridden per-query using the USING clause in SELECT.
         """
         mock_get_completion.return_value = [{"type": "data", "content": "-"}]
 
+        set_openai_completion(mock_openai, action_response(text="hi"), add_planning=False)
         self.run_sql(
             """
             CREATE AGENT override_agent
             USING
-                model = 'gpt-4o',
-                openai_api_key = 'sk-override',
+                model={
+                  "model_name": "gpt-4o",
+                  "api_key": 'sk-override'
+                },
                 prompt_template = 'Answer questions',
                 timeout = 60;
             """
diff --git a/tests/unit/executor/test_api_handler.py b/tests/unit/executor/test_api_handler.py
index cbc6a8ff862..beb696d2f3c 100644
--- a/tests/unit/executor/test_api_handler.py
+++ b/tests/unit/executor/test_api_handler.py
@@ -1,15 +1,14 @@
 import sys
 import types
 
-from unittest.mock import patch
 import datetime as dt
+from unittest.mock import patch
+from dataclasses import dataclass
 
 import pandas as pd
 
 from tests.unit.executor_test_base import BaseExecutorDummyML
 
-from dataclasses import dataclass
-
 
 # import modules virtually if it is not installed
 try:
diff --git a/tests/unit/executor/test_base_queires.py b/tests/unit/executor/test_base_queires.py
index 5fbece5c4d3..0a0e3c2ab79 100644
--- a/tests/unit/executor/test_base_queires.py
+++ b/tests/unit/executor/test_base_queires.py
@@ -899,6 +899,40 @@ def test_subselect_1row_aggregate(self, data_handler):
         assert len(ret) == 1
         assert ret["result"][0] == 1
 
+    @patch("mindsdb.integrations.handlers.postgres_handler.Handler")
+    def test_cte_join(self, data_handler):
+        self.set_handler(data_handler, name="pg", tables={"stores": get_stores_df()})
+        self.save_file("regions", get_regions_df())
+
+        ret = self.run_sql("""
+            WITH regions AS (
+                SELECT DISTINCT id, name FROM files.regions
+            ),
+            stores AS (
+                SELECT * FROM pg.stores 
+                LIMIT 10 
+            )
+            SELECT format, region_id FROM pg.stores s 
+            JOIN regions r on r.id = s.region_id
+            WHERE s.format IN (SELECT format FROM stores WHERE format='a')
+            LIMIT 100;
+        """)
+        assert len(ret) > 1
+        assert ret["format"][0] == "a"
+
+    @patch("mindsdb.integrations.handlers.postgres_handler.Handler")
+    def test_view_duplicated_cols(self, data_handler):
+        self.set_handler(data_handler, name="pg", tables={"stores": get_stores_df(), "regions": get_regions_df()})
+
+        with pytest.raises(Exception):
+            # `id` exists in both tables, should raise an exception
+            self.run_sql("""
+                create view v1 (
+                   select * from pg.stores s
+                   join pg.regions r on r.id = s.region_id
+                )
+            """)
+
 
 class TestSet(BaseExecutorTest):
     @pytest.mark.parametrize("var", ["var", "@@var", "@@session.var", "session var"])
diff --git a/tests/unit/executor/test_executor.py b/tests/unit/executor/test_executor.py
index c901e7bab55..89a4acdfda5 100644
--- a/tests/unit/executor/test_executor.py
+++ b/tests/unit/executor/test_executor.py
@@ -11,7 +11,9 @@
 
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 
-from mindsdb.api.executor.utilities.sql import query_df
+from mindsdb_sql_parser import parse_sql
+
+from mindsdb.api.executor.utilities.sql import query_df, query_dfs
 
 # How to run:
 #  env PYTHONPATH=./ pytest tests/unit/test_executor.py
@@ -1618,6 +1620,75 @@ def test_query_df_functions(self):
         result = query_df(df, query)["result"][0]
         assert isinstance(result, dt.time)
 
+    def test_not_exists_correlated_subquery(self):
+        a = pd.DataFrame(
+            [
+                {"tab_num": 1, "shop": 1},
+                {"tab_num": 1, "shop": 2},
+                {"tab_num": 1, "shop": 3},
+                {"tab_num": 2, "shop": 1},
+                {"tab_num": 2, "shop": 2},
+                {"tab_num": 3, "shop": 1},
+            ]
+        )
+        b = pd.DataFrame([{"shop": 1}, {"shop": 2}, {"shop": 3}])
+
+        result = query_dfs(
+            {"A": a, "B": b},
+            parse_sql(
+                """
+                SELECT DISTINCT a1.tab_num
+                FROM A a1
+                WHERE NOT EXISTS (
+                    SELECT * FROM B b
+                    WHERE NOT EXISTS (
+                        SELECT * FROM A a2
+                        WHERE a2.tab_num = a1.tab_num AND a2.shop = b.shop
+                    )
+                )
+                """,
+                dialect="mindsdb",
+            ),
+        )
+
+        # Only tab_num=1 covers all shops {1, 2, 3}
+        assert list(result["tab_num"]) == [1]
+
+    def test_exists_correlated_subquery(self):
+        # EXISTS version: find tab_num values missing at least one shop.
+        # tab_num=2 misses shop=3, tab_num=3 misses shops 2 and 3.
+        a = pd.DataFrame(
+            [
+                {"tab_num": 1, "shop": 1},
+                {"tab_num": 1, "shop": 2},
+                {"tab_num": 1, "shop": 3},
+                {"tab_num": 2, "shop": 1},
+                {"tab_num": 2, "shop": 2},
+                {"tab_num": 3, "shop": 1},
+            ]
+        )
+        b = pd.DataFrame([{"shop": 1}, {"shop": 2}, {"shop": 3}])
+
+        result = query_dfs(
+            {"A": a, "B": b},
+            parse_sql(
+                """
+                SELECT DISTINCT a1.tab_num
+                FROM A a1
+                WHERE EXISTS (
+                    SELECT * FROM B b
+                    WHERE NOT EXISTS (
+                        SELECT * FROM A a2
+                        WHERE a2.tab_num = a1.tab_num AND a2.shop = b.shop
+                    )
+                )
+                """,
+                dialect="mindsdb",
+            ),
+        )
+
+        assert sorted(result["tab_num"].tolist()) == [2, 3]
+
 
 class TestIfExistsIfNotExists(BaseExecutorMockPredictor):
     def setup_method(self, method):
diff --git a/tests/unit/executor/test_files.py b/tests/unit/executor/test_files.py
index 0181da273fa..cdbee61fbdb 100644
--- a/tests/unit/executor/test_files.py
+++ b/tests/unit/executor/test_files.py
@@ -152,8 +152,8 @@ def test_multi_table_relational_division(self):
         """
         )
 
-        assert len(result) == 3
-        assert sorted(result["tab_num"].tolist()) == [1, 2, 3]
+        assert len(result) == 2
+        assert sorted(result["tab_num"].tolist()) == [1, 2]
 
     def test_multi_table_join_with_aliases(self):
         """Test JOIN with aliases and database prefixes"""
diff --git a/tests/unit/executor/test_knowledge_base.py b/tests/unit/executor/test_knowledge_base.py
index 485e9bb9e20..991166e45ab 100644
--- a/tests/unit/executor/test_knowledge_base.py
+++ b/tests/unit/executor/test_knowledge_base.py
@@ -1,6 +1,7 @@
 import time
 import json
 import tempfile
+import datetime as dt
 
 from unittest.mock import patch, MagicMock
 import threading
@@ -8,7 +9,6 @@
 
 import pandas as pd
 import pytest
-import sys
 
 from tests.unit.executor_test_base import BaseExecutorDummyML
 from mindsdb.integrations.utilities.rag.rerankers.base_reranker import (
@@ -32,12 +32,13 @@ def task_monitor():
     worker.join()
 
 
-def dummy_embeddings(string, dimension=None):
+def dummy_embeddings(string, dimension=None, base=None):
     # Imitates embedding generation: create vectors which are similar for similar words in inputs
     if dimension is None:
         dimension = 25**2
     embeds = [0] * dimension
-    base = 25
+    if base is None:
+        base = 25
 
     string = string.lower().replace(",", " ").replace(".", " ")
     for word in string.split():
@@ -60,13 +61,11 @@ def dummy_embeddings(string, dimension=None):
     return embeds
 
 
-def set_litellm_embedding(mock_litellm_embedding, dimension=None):
+def set_embedding(mock_embedding, dimension=None, base=None):
     def resp_f(input, *args, **kwargs):
-        mock_response = MagicMock()
-        mock_response.data = [{"embedding": dummy_embeddings(s, dimension)} for s in input]
-        return mock_response
+        return [dummy_embeddings(s, dimension, base) for s in input]
 
-    mock_litellm_embedding.side_effect = resp_f
+    mock_embedding().embeddings.side_effect = resp_f
 
 
 class BaseTestKB(BaseExecutorDummyML):
@@ -94,7 +93,7 @@ def _create_kb(
 
         if embedding_model is None:
             embedding_model = {
-                "provider": "bedrock",
+                "provider": "openai",
                 "model_name": "dummy_model",
                 "api_key": "dummy_key",
             }
@@ -133,7 +132,6 @@ def _create_kb(
         )
 
     def _get_storage_table(self, kb_name):
-        # default chromadb
         db_name = f"db_{kb_name}"
 
         self._drop_storage_db(db_name)
@@ -141,10 +139,7 @@ def _get_storage_table(self, kb_name):
         self.run_sql(f"""
           create database {db_name} 
            with 
-           engine='chromadb',
-           PARAMETERS = {{
-               'persist_directory': '{kb_name}'
-           }}
+           engine='duckdb_faiss'
         """)
         self.storages.append(db_name)
 
@@ -172,16 +167,16 @@ def _get_ral_table(self):
         return pd.DataFrame(data, columns=["ral", "english", "italian"])
 
 
-class TestKB(BaseTestKB):
+class TestKBNOAutoBatch(BaseTestKB):
     def setup_method(self):
         super().setup_method()
         from mindsdb.utilities.config import config
 
         config["knowledge_bases"]["disable_autobatch"] = True
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_kb(self, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_kb(self, mock_embedding):
+        set_embedding(mock_embedding)
 
         self._create_kb("kb_review")
 
@@ -191,7 +186,7 @@ def test_kb(self, mock_litellm_embedding):
         ret = self.run_sql("select * from kb_review")
         assert len(ret) == 1
 
-        # show tables in default chromadb
+        # show tables in default vectordb
         ret = self.run_sql("show knowledge bases")
 
         db_name = ret.STORAGE[0].split(".")[0]
@@ -199,9 +194,9 @@ def test_kb(self, mock_litellm_embedding):
         # only one default collection there
         assert len(ret) == 1
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_kb_metadata(self, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_kb_metadata(self, mock_embedding):
+        set_embedding(mock_embedding)
 
         record = {
             "review": "all is good, haven't used yet",
@@ -412,9 +407,9 @@ async def _fake_call_llm(messages):
         # Fallback pattern should be descending
         assert scores[0] > scores[1] > scores[2]
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_join_kb_table(self, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_join_kb_table(self, mock_embedding):
+        set_embedding(mock_embedding)
 
         df = self._get_ral_table()
         self.save_file("ral", df)
@@ -480,15 +475,12 @@ def test_join_kb_table(self, mock_litellm_embedding):
         assert set(ret["id"]) == {"9016", "9023"}
 
     @pytest.mark.slow
-    @pytest.mark.skipif(sys.platform == "win32", reason="Causes hard crash on windows.")
-    @pytest.mark.skipif(sys.platform == "darwin", reason="Causes hard crash on mac.")
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
     @patch("mindsdb.integrations.handlers.postgres_handler.Handler")
-    def test_kb_partitions(self, mock_handler, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    def test_kb_partitions(self, mock_handler, mock_embedding):
+        set_embedding(mock_embedding)
 
         df = self._get_ral_table()
-        self.save_file("ral", df)
 
         df = pd.concat([df] * 30)
         # unique ids
@@ -555,7 +547,15 @@ def stream_f(*args, **kwargs):
                     yield df[chunk_size * i : chunk_size * (i + 1) :]
 
             # --- stream mode ---
-            mock_handler().query_stream.side_effect = stream_f
+            # Mock native_query to return TableResponse with generator
+            mock_handler().stream_response = True
+
+            def native_query_with_generator(*args, **kwargs):
+                from mindsdb.integrations.libs.response import TableResponse
+
+                return TableResponse(data_generator=stream_f())
+
+            mock_handler().native_query.side_effect = native_query_with_generator
 
             # test iterate
             check_partition(
@@ -573,13 +573,14 @@ def stream_f(*args, **kwargs):
             """
             )
 
-            # test threads
-            check_partition(
-                """
-                insert into kb_part SELECT id, english FROM pg.ral
-                using batch_size=20, track_column=id, threads = 3
-            """
-            )
+            # switched off for faiss
+            # # test threads
+            # check_partition(
+            #     """
+            #     insert into kb_part SELECT id, english FROM pg.ral
+            #     using batch_size=20, track_column=id, threads = 3
+            # """
+            # )
 
             # without track column
             check_partition(
@@ -590,7 +591,15 @@ def stream_f(*args, **kwargs):
             )
 
             # --- general mode ---
-            mock_handler().query_stream = None
+            # Mock native_query to return TableResponse with full data
+            mock_handler().stream_response = False
+
+            def native_query_without_generator(*args, **kwargs):
+                from mindsdb.integrations.libs.response import TableResponse
+
+                return TableResponse(data=df)
+
+            mock_handler().native_query.side_effect = native_query_without_generator
 
             # test iterate
             check_partition(
@@ -600,25 +609,26 @@ def stream_f(*args, **kwargs):
             """
             )
 
-            # test threads
-            check_partition(
-                """
-                insert into kb_part SELECT id, english FROM pg.ral
-                using batch_size=20, track_column=id, threads = 3
-            """
-            )
+            # switched off for faiss
+            # # test threads
+            # check_partition(
+            #     """
+            #     insert into kb_part SELECT id, english FROM pg.ral
+            #     using batch_size=20, track_column=id, threads = 3
+            # """
+            # )
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_kb_algebra(self, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_kb_algebra(self, mock_embedding):
+        set_embedding(mock_embedding)
 
         lines, i = [], 0
         for color in ("white", "red", "green"):
             for size in ("big", "middle", "small"):
                 for shape in ("square", "triangle", "circle"):
                     i += 1
-                    lines.append([i, i, f"{color} {size} {shape}", color, size, shape])
-        df = pd.DataFrame(lines, columns=["id", "num", "content", "color", "size", "shape"])
+                    lines.append([i, i, f"{color} {size} {shape}", color, size, shape, dt.date(2000, 1, i)])
+        df = pd.DataFrame(lines, columns=["id", "num", "content", "color", "size", "shape", "valid_date"])
 
         self.save_file("items", df)
 
@@ -727,9 +737,46 @@ def test_kb_algebra(self, mock_litellm_embedding):
             else:
                 assert "small" in content
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_select_allowed_columns(self, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+        # -- metadata: like, not like
+        for query in ("trian%", "%riangl%", "%angle"):
+            ret = self.run_sql(f"select * from kb_alg where shape like '{query}'")
+
+            # only triangle
+            assert set(ret["shape"]) == {"triangle"}
+
+        # -- metadata: '>=', '>', '<=', '<'
+
+        ret = self.run_sql("select * from kb_alg where color > 'red'")
+        # only white
+        assert set(ret["color"]) == {"white"}
+
+        ret = self.run_sql("select * from kb_alg where color < 'red'")
+        # only green
+        assert set(ret["color"]) == {"green"}
+
+        ret = self.run_sql("select * from kb_alg where color <= 'red' and color > 'green'")
+        # only red
+        assert set(ret["color"]) == {"red"}
+
+        # filter by int
+        ret = self.run_sql("select * from kb_alg where num >= 10")
+        assert ret["num"].min() == 10
+
+        # filter by date
+        ret = self.run_sql("select * from kb_alg where valid_date >= '2000-01-15'")
+        assert ret["valid_date"].min() > "2000-01-14" and ret["valid_date"].min() < "2000-01-16"
+
+        ret = self.run_sql("select * from kb_alg where valid_date < '2000-01-15'")
+        assert ret["valid_date"].max() > "2000-01-13" and ret["valid_date"].min() < "2000-01-15"
+
+        # -- filter by id and content
+        ret = self.run_sql("select * from kb_alg where content = 'green' and id < 22")
+        assert ret["color"][0] == "green"
+        assert ret["id"].max() < 22
+
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_select_allowed_columns(self, mock_embedding):
+        set_embedding(mock_embedding)
 
         # -- no metadata are specified, generated from inserts --
         self._create_kb("kb1")
@@ -772,9 +819,9 @@ def test_select_allowed_columns(self, mock_litellm_embedding):
 
     @patch("mindsdb.interfaces.knowledge_base.llm_client.OpenAI")
     @patch("mindsdb.integrations.utilities.rag.rerankers.base_reranker.BaseLLMReranker.get_scores")
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_evaluate(self, mock_litellm_embedding, mock_get_scores, mock_openai):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_evaluate(self, mock_embedding, mock_get_scores, mock_openai):
+        set_embedding(mock_embedding)
 
         question, answer = "2+2", "4"
         agent_response = f"""
@@ -892,13 +939,13 @@ def test_evaluate(self, mock_litellm_embedding, mock_get_scores, mock_openai):
         assert len(df) > 0
 
     @patch("mindsdb.utilities.config.Config.get")
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
     @patch("mindsdb.integrations.utilities.rag.rerankers.base_reranker.BaseLLMReranker.get_scores")
-    def test_save_default_params(self, mock_get_scores, mock_litellm_embedding, mock_config_get):
+    def test_save_default_params(self, mock_get_scores, mock_embedding, mock_config_get):
         # reranking result
         mock_get_scores.side_effect = lambda query, docs: [0.8 for _ in docs]
 
-        set_litellm_embedding(mock_litellm_embedding)
+        set_embedding(mock_embedding)
 
         def config_get_side_effect(key, default=None):
             if key == "default_embedding_model":
@@ -932,10 +979,10 @@ def config_get_side_effect(key, default=None):
 
         assert "openai_model" not in ret["RERANKING_MODEL"][0]
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_relevance_filtering_gt_operator(self, mock_litellm_embedding):
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_relevance_filtering_gt_operator(self, mock_embedding):
         """Test relevance filtering with GREATER_THAN operator"""
-        set_litellm_embedding(mock_litellm_embedding)
+        set_embedding(mock_embedding)
 
         test_data = [
             {"id": "1", "content": "This is about machine learning and AI"},
@@ -966,9 +1013,9 @@ def test_relevance_filtering_gt_operator(self, mock_litellm_embedding):
         assert isinstance(ret, pd.DataFrame)
 
     @patch("mindsdb.integrations.utilities.rag.rerankers.base_reranker.BaseLLMReranker.get_scores")
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_alter_kb(self, mock_litellm_embedding, mock_get_scores):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_alter_kb(self, mock_embedding, mock_get_scores):
+        set_embedding(mock_embedding)
 
         self._create_kb(
             "kb1",
@@ -1022,6 +1069,11 @@ def test_alter_kb(self, mock_litellm_embedding, mock_get_scores):
         assert kb.params["reranking_model"]["provider"] == "ollama"
         assert "api_key" not in kb.params["reranking_model"]
 
+        # disable reranking model and ensure config is cleared
+        self.run_sql("ALTER KNOWLEDGE BASE kb1 USING reranking_model = false")
+        kb = self.db.KnowledgeBase.query.filter_by(name="kb1").first()
+        assert kb.params["reranking_model"] == {}
+
     @patch("mindsdb.integrations.utilities.rag.rerankers.base_reranker.BaseLLMReranker.get_scores")
     @patch("mindsdb.interfaces.knowledge_base.llm_client.OpenAI")
     def test_ollama(self, mock_openai, mock_get_scores):
@@ -1042,9 +1094,9 @@ def test_ollama(self, mock_openai, mock_get_scores):
         assert "api_key" not in ret["EMBEDDING_MODEL"][0]
         assert "api_key" not in ret["RERANKING_MODEL"][0]
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_kb_uppercase_source_columns(self, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_kb_uppercase_source_columns(self, mock_embedding):
+        set_embedding(mock_embedding)
 
         df = pd.DataFrame(
             [
@@ -1116,37 +1168,37 @@ def test_kb_uppercase_source_columns(self, mock_litellm_embedding):
         assert len(ret) == 2
         assert ret["category"][0] == "Home"
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_dimension_mismatch(self, mock_litellm_embedding):
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_dimension_mismatch(self, mock_embedding):
         temp_dir = tempfile.mkdtemp()
 
         self.run_sql(f"""
-        create database my_chroma 
-          with 
-           engine='chromadb',
+        create database my_faiss
+          with
+           engine='duckdb_faiss',
            PARAMETERS = {{
                'persist_directory': '{temp_dir}'
            }}
         """)
 
-        set_litellm_embedding(mock_litellm_embedding, dimension=1000)
-        self._create_kb("kb1", storage="my_chroma.table1")
+        set_embedding(mock_embedding, dimension=1000)
+        self._create_kb("kb1", storage="my_faiss.table1")
 
         self.run_sql("insert into kb1 (content) values ('review')")
 
         # change dimension
-        set_litellm_embedding(mock_litellm_embedding, dimension=1500)
+        set_embedding(mock_embedding, dimension=1500)
 
         with pytest.raises(ValueError):
-            self._create_kb("kb2", storage="my_chroma.table1")
+            self._create_kb("kb2", storage="my_faiss.table1")
 
         self.run_sql("drop knowledge base kb1")
-        self.run_sql("drop table my_chroma.table1")
-        self.run_sql("drop database my_chroma")
+        self.run_sql("drop table my_faiss.table1")
+        self.run_sql("drop database my_faiss")
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_duplicated_ids(self, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_duplicated_ids(self, mock_embedding):
+        set_embedding(mock_embedding)
 
         self._create_kb("kb1")
 
@@ -1176,9 +1228,9 @@ def test_duplicated_ids(self, mock_litellm_embedding):
         ret = self.run_sql("select * from kb1 where id = 2")
         assert len(ret) == 1
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_update(self, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_update(self, mock_embedding):
+        set_embedding(mock_embedding)
 
         self._create_kb("kb1")
 
@@ -1195,11 +1247,116 @@ def test_update(self, mock_litellm_embedding):
         assert len(ret) == 1
         assert ret["chunk_content"][0] == "dog"
 
+    @patch("mindsdb.integrations.utilities.rag.rerankers.base_reranker.BaseLLMReranker.get_scores")
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_reranking(self, mock_embedding, mock_get_scores):
+        set_embedding(mock_embedding)
+
+        self._create_kb(
+            "kb_ral",
+            content_columns=["english"],
+            reranking_model={
+                "provider": "openai",
+                "model_name": "gpt-3",
+                "api_key": "embed-key-1",
+            },
+        )
+
+        df = self._get_ral_table()
+        self.save_file("ral", df)
+
+        self.run_sql(
+            """
+                insert into kb_ral
+                select * from files.ral
+            """
+        )
+
+        # rank from greater to lower
+        mock_get_scores.side_effect = lambda query, docs: [1 - i / 4 for i in range(len(docs))]
+        ret = self.run_sql("select * from kb_ral where content='white'")
+        assert "white" in ret["chunk_content"].iloc[0]
+
+        # reverse rank: from lower to greater. the most semantic result have to be moved back
+        mock_get_scores.side_effect = lambda query, docs: [i / 4 for i in range(len(docs))]
+        ret = self.run_sql("select * from kb_ral where content='white'")
+        assert "white" not in ret["chunk_content"].iloc[0]
+
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_hybrid_search(self, mock_embedding):
+        df = self._get_ral_table()
+        self.save_file("ral", df)
+
+        set_embedding(mock_embedding)
+
+        self._create_kb("kb_hybrid", content_columns=["english"])
+
+        self.run_sql("insert into kb_hybrid  select * from files.ral")
+
+        # changing embedding config, making semantic search irrelevant
+        set_embedding(mock_embedding, base=20)
+
+        # white is not at the top
+        ret = self.run_sql("select * from kb_hybrid where content='white'")
+        assert "white" not in ret["chunk_content"].iloc[0]
+
+        # but it is when hybrid search is used
+        ret = self.run_sql("""
+            select * from kb_hybrid where content='white'
+            and hybrid_search_alpha = 0
+        """)
+        assert "white" in ret["chunk_content"].iloc[0]
+
+        # checking alpha=0.5
+        ret = self.run_sql("""
+            select * from kb_hybrid where content='white'
+            and hybrid_search = true
+        """)
+        assert "white" in ret["chunk_content"].iloc[0]
+
+    # @pytest.mark.slow
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_create_index(self, mock_embedding):
+        set_embedding(mock_embedding)
+
+        df = self._get_ral_table()
+
+        df = pd.concat([df] * 30)
+        # unique ids
+        df["id"] = list(map(str, range(len(df))))
+        self.save_file("ral", df)
+
+        # create kb, fill it
+        self._create_kb("kb_ral", content_columns=["english"])
+
+        self.run_sql("insert into kb_ral select * from files.ral")
+
+        # create index default index (ivf_file, for windows it is ivf)
+        self.run_sql(
+            """
+            CREATE INDEX ON KNOWLEDGE_BASE kb_ral WITH (nlist=1)
+            """
+        )
+
+        # check kb works after index was created
+        ret = self.run_sql("select * from kb_ral where content='white'")
+        assert "white" in ret["chunk_content"].iloc[0]
+
+        # specified index
+        self.run_sql(
+            """
+            CREATE INDEX ON KNOWLEDGE_BASE kb_ral
+            WITH (nlist=1, type='ivf', train_count=50)
+            """
+        )
+        ret = self.run_sql("select * from kb_ral where content='white'")
+        assert "white" in ret["chunk_content"].iloc[0]
+
 
 class TestKBAutoBatch(BaseTestKB):
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_no_autobatch(self, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_no_autobatch(self, mock_embedding):
+        set_embedding(mock_embedding)
         df = self._get_ral_table()
         self.save_file("ral", df)
 
@@ -1219,9 +1376,9 @@ def test_no_autobatch(self, mock_litellm_embedding):
         ret = self.run_sql("select * from kb_ral limit 1")
         assert len(ret) == 1
 
-    @patch("mindsdb.integrations.handlers.litellm_handler.litellm_handler.embedding")
-    def test_autobatch(self, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
+    def test_autobatch(self, mock_embedding):
+        set_embedding(mock_embedding)
         df = self._get_ral_table()
         self.save_file("ral", df)
 
diff --git a/tests/unit/executor/test_lowercase.py b/tests/unit/executor/test_lowercase.py
index 8f8e0a74870..d7e9d2a32b0 100644
--- a/tests/unit/executor/test_lowercase.py
+++ b/tests/unit/executor/test_lowercase.py
@@ -4,7 +4,7 @@
 import pandas as pd
 
 from tests.unit.executor_test_base import BaseExecutorDummyML
-from tests.unit.executor.test_agent import set_litellm_embedding
+from tests.unit.executor.test_agent import set_embedding
 
 
 class TestLowercase(BaseExecutorDummyML):
@@ -166,13 +166,15 @@ def test_model_name_lowercase(self):
                 self.run_sql(f"DROP MODEL `{another_name}`")
             self.run_sql(f"DROP MODEL {another_name}")
 
-    def test_agent_name_lowercase(self):
+    @patch("mindsdb.interfaces.agents.agents_controller.check_agent_llm")
+    def test_agent_name_lowercase(self, check_agent_llm):
         agent_params = """
-                model='gpt-3.5-turbo',
-                provider='openai',
+                model={
+                    "model_name": "gpt-3.5-turbo",
+                    "provider": "openai"
+                },
                 prompt_template='Answer the user input in a helpful way using tools',
-                max_iterations=5,
-                mode='retrieval'
+                mode='text'
         """
 
         # mixed case: agent
@@ -204,18 +206,14 @@ def test_agent_name_lowercase(self):
                 self.run_sql(f"drop agent `{another_agent_name}`")
             self.run_sql(f"drop agent {another_agent_name}")
 
-    @patch("litellm.embedding")
+    @patch("mindsdb.interfaces.knowledge_base.controller.LLMClient")
     @patch("openai.OpenAI")
-    def test_knowledgebase_name_lowercase(self, mock_openai, mock_litellm_embedding):
-        set_litellm_embedding(mock_litellm_embedding)
+    def test_knowledgebase_name_lowercase(self, mock_openai, mock_embedding):
+        set_embedding(mock_embedding)
 
         self.run_sql("""
           create database my_kb_storage 
-           with 
-           engine='chromadb',
-           PARAMETERS = {
-               'persist_directory': 'my_kb_storage'
-           }
+           with  engine='duckdb_faiss'
         """)
 
         kb_params = """
@@ -278,7 +276,8 @@ def test_job_name_lowercase(self):
 
             self.run_sql(f"DROP JOB {another_name}")
 
-    def test_chatbot_lowercase(self):
+    @patch("mindsdb.interfaces.agents.agents_controller.check_agent_llm")
+    def test_chatbot_lowercase(self, check_agent_llm):
         self.run_sql("create agent my_agent using model={'provider': 'openai', 'model_name': 'gpt-3.5'}")
 
         self.run_sql("create database my_db using engine='dummy_data'")
diff --git a/tests/unit/executor/test_schema.py b/tests/unit/executor/test_schema.py
index 8c80177c006..540467a9c78 100644
--- a/tests/unit/executor/test_schema.py
+++ b/tests/unit/executor/test_schema.py
@@ -12,7 +12,8 @@ def test_show(self):
             self.run_sql(f"show {item}")
 
     @pytest.mark.slow
-    def test_schema(self):
+    @patch("mindsdb.interfaces.agents.agents_controller.check_agent_llm")
+    def test_schema(self, check_agent):
         # --- create objects + describe ---
         # todo: create knowledge base (requires chromadb)
 
@@ -91,15 +92,15 @@ def test_schema(self):
         # agent
         self.run_sql("""
               CREATE AGENT agent1
-              USING model = 'pred1'
+              USING model = {'model_name': "pred1", "provider": "openai"}
         """)
         self.run_sql("""
               CREATE AGENT proj2.agent2
-              USING model = 'pred2' -- it looks up in agent's project
+              USING model =  {'model_name': "pred2", "provider": "openai"} -- it looks up in agent's project
         """)
 
         df = self.run_sql("describe agent agent1")
-        assert df.NAME[0] == "agent1" and df.MODEL_NAME[0] == "pred1"
+        assert df.NAME[0] == "agent1" and "pred1" in df.MODEL[0]
 
         # chatbot
         self.run_sql("""
diff --git a/tests/unit/executor_test_base.py b/tests/unit/executor_test_base.py
index d305cd9d90f..a2ebbed7ba6 100644
--- a/tests/unit/executor_test_base.py
+++ b/tests/unit/executor_test_base.py
@@ -59,6 +59,8 @@ def setup_class(cls):
         with open(cfg_file, "w") as fd:
             json.dump(config, fd)
 
+        cls._original_storage_dir_env = os.environ.get("MINDSDB_STORAGE_DIR")
+        cls._original_config_path_env = os.environ.get("MINDSDB_CONFIG_PATH")
         os.environ["MINDSDB_STORAGE_DIR"] = cls.storage_dir
         os.environ["MINDSDB_CONFIG_PATH"] = cfg_file
 
@@ -83,6 +85,11 @@ def teardown_class(cls):
             if env_var_name in os.environ:
                 del os.environ[env_var_name]
 
+        if cls._original_storage_dir_env is not None:
+            os.environ["MINDSDB_STORAGE_DIR"] = cls._original_storage_dir_env
+        if cls._original_config_path_env is not None:
+            os.environ["MINDSDB_CONFIG_PATH"] = cls._original_config_path_env
+
         # remove import of mindsdb for next tests
         unload_module("mindsdb")
 
@@ -339,11 +346,10 @@ def set_handler(self, mock_handler, name, tables, engine="postgres", schema=None
         self.db.session.add(r)
         self.db.session.commit()
 
-        from mindsdb.integrations.libs.response import RESPONSE_TYPE
-        from mindsdb.integrations.libs.response import HandlerResponse as Response
+        from mindsdb.integrations.libs.response import TableResponse
 
         def handler_response(df, affected_rows: None | int = None):
-            response = Response(RESPONSE_TYPE.TABLE, df, affected_rows=affected_rows)
+            response = TableResponse(data=df, affected_rows=affected_rows)
             return response
 
         def get_tables_f():
diff --git a/tests/unit/handlers/base_handler_test.py b/tests/unit/handlers/base_handler_test.py
index 85e4133fbfc..be54f494402 100644
--- a/tests/unit/handlers/base_handler_test.py
+++ b/tests/unit/handlers/base_handler_test.py
@@ -2,7 +2,7 @@
 from unittest.mock import MagicMock, Mock
 
 from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response,
+    DataHandlerResponse as Response,
     HandlerStatusResponse as StatusResponse,
 )
 
@@ -167,22 +167,6 @@ def get_columns_query(self):
         """
         pass
 
-    def test_native_query(self):
-        """
-        Tests the `native_query` method to ensure it executes a SQL query using a mock cursor and returns a Response object.
-        """
-        mock_conn = MagicMock()
-        mock_cursor = MockCursorContextManager()
-
-        self.handler.connect = MagicMock(return_value=mock_conn)
-        mock_conn.cursor = MagicMock(return_value=mock_cursor)
-
-        query_str = f"SELECT * FROM {self.mock_table}"
-        data = self.handler.native_query(query_str)
-
-        assert isinstance(data, Response)
-        self.assertFalse(data.error_code)
-
     def test_get_columns(self):
         """
         Tests if the `get_tables` method calls `native_query` with the correct SQL query.
diff --git a/tests/unit/handlers/test_bigquery.py b/tests/unit/handlers/test_bigquery.py
index 1bb69de1a11..448af57d609 100644
--- a/tests/unit/handlers/test_bigquery.py
+++ b/tests/unit/handlers/test_bigquery.py
@@ -6,9 +6,10 @@
 from google.api_core.exceptions import BadRequest
 
 from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response,
     HandlerStatusResponse as StatusResponse,
     RESPONSE_TYPE,
+    TableResponse,
+    ErrorResponse,
 )
 
 try:
@@ -76,7 +77,7 @@ def test_native_query(self):
         self.handler.connect = MagicMock(return_value=mock_conn)
 
         mock_query = MagicMock()
-        mock_query.to_dataframe.return_value = None
+        mock_query.to_dataframe.return_value = pd.DataFrame({"col": [1, 2, 3]})
         mock_conn.query.return_value = mock_query
 
         query_str = "SELECT * FROM table"
@@ -87,8 +88,35 @@ def test_native_query(self):
             mock_query_job_config_instance = mock_query_job_config.return_value
             data = self.handler.native_query(query_str)
             mock_conn.query.assert_called_once_with(query_str, job_config=mock_query_job_config_instance)
-            assert isinstance(data, Response)
-            self.assertFalse(data.error_code)
+            assert isinstance(data, TableResponse)
+
+    def test_native_query_empty_select_returns_table(self):
+        mock_conn = MagicMock()
+        self.handler.connect = MagicMock(return_value=mock_conn)
+
+        mock_query = MagicMock()
+        mock_query.to_dataframe.return_value = pd.DataFrame(columns=["id"])
+        mock_conn.query.return_value = mock_query
+
+        with patch("mindsdb.integrations.handlers.bigquery_handler.bigquery_handler.QueryJobConfig"):
+            response = self.handler.native_query("SELECT id FROM table WHERE 1 = 0")
+
+        self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
+        self.assertEqual(list(response.data_frame.columns), ["id"])
+        self.assertTrue(response.data_frame.empty)
+
+    def test_native_query_empty_dataframe_without_columns_returns_ok(self):
+        mock_conn = MagicMock()
+        self.handler.connect = MagicMock(return_value=mock_conn)
+
+        mock_query = MagicMock()
+        mock_query.to_dataframe.return_value = pd.DataFrame()
+        mock_conn.query.return_value = mock_query
+
+        with patch("mindsdb.integrations.handlers.bigquery_handler.bigquery_handler.QueryJobConfig"):
+            response = self.handler.native_query("UPDATE table SET col = 1")
+
+        self.assertEqual(response.type, RESPONSE_TYPE.OK)
 
     def test_get_tables(self):
         """
@@ -124,7 +152,7 @@ def test_get_columns(self):
         self.handler.native_query.assert_called_once_with(expected_query)
 
     def test_meta_get_tables_filters(self):
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame()))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=pd.DataFrame()))
 
         self.handler.meta_get_tables(table_names=["orders"])
 
@@ -132,7 +160,7 @@ def test_meta_get_tables_filters(self):
         self.assertIn("AND t.table_name IN ('orders')", query)
 
     def test_meta_get_columns_filters(self):
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame()))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=pd.DataFrame()))
 
         self.handler.meta_get_columns(table_names=["orders"])
 
@@ -176,9 +204,9 @@ def test_meta_get_column_statistics_batches_results(self):
 
         self.handler.native_query = MagicMock(
             side_effect=[
-                Response(RESPONSE_TYPE.TABLE, data_frame=column_types_result),
-                Response(RESPONSE_TYPE.TABLE, data_frame=first_batch_result),
-                Response(RESPONSE_TYPE.TABLE, data_frame=second_batch_result),
+                TableResponse(data=column_types_result),
+                TableResponse(data=first_batch_result),
+                TableResponse(data=second_batch_result),
             ]
         )
 
@@ -189,20 +217,21 @@ def test_meta_get_column_statistics_batches_results(self):
         self.assertEqual(self.handler.native_query.call_count, 3)  # 1 for column types + 2 for batches
 
     def test_meta_get_column_statistics_returns_error_when_empty(self):
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.ERROR, error_message="boom"))
+        self.handler.native_query = MagicMock(return_value=ErrorResponse(error_message="boom"))
 
         response = self.handler.meta_get_column_statistics_for_table("table", ["col"])
         self.assertEqual(response.resp_type, RESPONSE_TYPE.ERROR)
 
     def test_meta_get_primary_keys_filters(self):
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame()))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=pd.DataFrame()))
         self.handler.meta_get_primary_keys(table_names=["orders"])
 
         query = self.handler.native_query.call_args[0][0]
         self.assertIn("AND tc.table_name IN ('orders')", query)
+        self.assertNotIn("tc.constraint_name,", query)
 
     def test_meta_get_foreign_keys_filters(self):
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame()))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=pd.DataFrame()))
         self.handler.meta_get_foreign_keys(table_names=["orders"])
         query = self.handler.native_query.call_args[0][0]
         self.assertIn("AND tc.table_name IN ('orders')", query)
diff --git a/tests/unit/handlers/test_clickhouse.py b/tests/unit/handlers/test_clickhouse.py
index 404c888a4d7..68ec1d895fd 100644
--- a/tests/unit/handlers/test_clickhouse.py
+++ b/tests/unit/handlers/test_clickhouse.py
@@ -6,7 +6,8 @@
 from sqlalchemy.exc import SQLAlchemyError
 from mindsdb_sql_parser import parse_sql
 
-from base_handler_test import BaseDatabaseHandlerTest
+from base_handler_test import BaseDatabaseHandlerTest, MockCursorContextManager
+from mindsdb.integrations.libs.response import TableResponse
 
 try:
     from mindsdb.integrations.handlers.clickhouse_handler.clickhouse_handler import ClickHouseHandler
@@ -67,6 +68,21 @@ def test_connect_success(self):
             f"clickhouse+{self.dummy_connection_data['protocol']}://{self.dummy_connection_data['user']}:{self.dummy_connection_data['password']}@{self.dummy_connection_data['host']}:{self.dummy_connection_data['port']}/{self.dummy_connection_data['database']}"
         )
 
+    def test_native_query(self):
+        """
+        Tests the `native_query` method to ensure it executes a SQL query using a mock cursor and returns a Response object.
+        """
+        mock_conn = MagicMock()
+        mock_cursor = MockCursorContextManager()
+
+        self.handler.connect = MagicMock(return_value=mock_conn)
+        mock_conn.cursor = MagicMock(return_value=mock_cursor)
+
+        query_str = f"SELECT * FROM {self.mock_table}"
+        data = self.handler.native_query(query_str)
+
+        assert isinstance(data, TableResponse)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/unit/handlers/test_confluence.py b/tests/unit/handlers/test_confluence.py
index f5af306caff..9febdd68807 100644
--- a/tests/unit/handlers/test_confluence.py
+++ b/tests/unit/handlers/test_confluence.py
@@ -15,16 +15,8 @@
     ConfluenceWhiteboardsTable,
     ConfluenceTasksTable,
 )
-from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response,
-    HandlerStatusResponse as StatusResponse,
-    RESPONSE_TYPE,
-)
-from mindsdb.integrations.utilities.sql_utils import (
-    FilterCondition,
-    FilterOperator,
-    SortColumn,
-)
+from mindsdb.integrations.libs.response import TableResponse, HandlerStatusResponse as StatusResponse, RESPONSE_TYPE
+from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator, SortColumn
 
 
 class TestConfluenceHandler(BaseHandlerTestSetup, unittest.TestCase):
@@ -101,23 +93,47 @@ def test_check_connection_failure(self):
             json=None,
         )
 
+    def test_check_connection_self_hosted_uses_server_api(self):
+        """
+        Test that the legacy self-hosted flag routes requests to the Confluence Server API.
+        """
+        self.handler.connection_data["is_selfHosted"] = True
+
+        mock_request = MagicMock()
+        mock_request.return_value = MagicMock(
+            status_code=200,
+            raise_for_status=lambda: None,
+            json=lambda: dict(results=[], _links=dict(next=None)),
+        )
+        self.mock_connect.return_value = MagicMock(request=mock_request)
+
+        response = self.handler.check_connection()
+
+        self.assertTrue(response.success)
+        self.mock_connect.return_value.request.assert_called_with(
+            "GET",
+            f"{self.dummy_connection_data['api_base']}/rest/api/space",
+            params={"expand": "description.view,homepage", "limit": 1},
+            json=None,
+        )
+
     def test_get_tables(self):
         """
-        Test that the `get_tables` method returns a list of table names.
+        Test that the `get_tables` method returns a TableResponse with a list of table names.
         """
         response = self.handler.get_tables()
 
-        self.assertIsInstance(response, Response)
+        self.assertIsInstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
         self.assertEqual(response.data_frame.columns.tolist(), ["table_name", "table_type"])
 
     def test_get_columns(self):
         """
-        Test that the `get_columns` method returns a list of columns for a table.
+        Test that the `get_columns` method returns a TableResponse with a list of columns for a table.
         """
         response = self.handler.get_columns("spaces")
 
-        self.assertIsInstance(response, Response)
+        self.assertIsInstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
         self.assertEqual(response.data_frame.columns.tolist(), ["Field", "Type"])
 
diff --git a/tests/unit/handlers/test_databricks.py b/tests/unit/handlers/test_databricks.py
index df976cc4ce6..659a389a1ed 100644
--- a/tests/unit/handlers/test_databricks.py
+++ b/tests/unit/handlers/test_databricks.py
@@ -19,7 +19,10 @@
     DATABRICKS_AVAILABLE = False
 
 from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response,
+    TableResponse,
+    ErrorResponse,
+    OkResponse,
+    DataHandlerResponse,
     RESPONSE_TYPE,
     HandlerStatusResponse as StatusResponse,
 )
@@ -171,7 +174,7 @@ def tearDown(self):
 
     def test_native_query(self):
         """
-        Tests the `native_query` method to ensure it executes a SQL query using a mock cursor and returns a Response object.
+        Tests the `native_query` method to ensure it executes a SQL query using a mock cursor and returns a TableResponse object.
         """
         self.mock_cursor.set_results([], [])
 
@@ -179,8 +182,17 @@ def test_native_query(self):
         data = self.handler.native_query(query_str)
 
         self.mock_cursor.execute.assert_called_once_with(query_str)
-        self.assertIsInstance(data, Response)
-        self.assertFalse(data.error_code)
+        self.assertIsInstance(data, DataHandlerResponse)
+        self.assertNotIsInstance(data, ErrorResponse)
+
+    def test_native_query_empty_select_returns_table(self):
+        self.mock_cursor.set_results([], ["id", "name"])
+
+        response = self.handler.native_query("SELECT id, name FROM table WHERE 1 = 0")
+
+        self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
+        self.assertEqual(list(response.data_frame.columns), ["id", "name"])
+        self.assertEqual(len(response.data_frame), 0)
 
     def test_get_tables(self):
         """
@@ -202,6 +214,14 @@ def test_get_tables(self):
         """
         self.handler.native_query.assert_called_once_with(expected_query)
 
+    def test_get_tables_returns_non_table_response_without_transform(self):
+        expected = ErrorResponse(error_message="boom")
+        self.handler.native_query = MagicMock(return_value=expected)
+
+        result = self.handler.get_tables()
+
+        self.assertIs(result, expected)
+
     def test_get_columns(self):
         """
         Tests if the `get_columns` method correctly constructs the SQL query and if it calls `native_query` with the correct query.
@@ -241,14 +261,12 @@ def test_native_query_server_error(self):
 
         result = self.handler.native_query("SELECT * FROM test_table")
 
-        self.assertEqual(result.type, RESPONSE_TYPE.ERROR)
+        self.assertIsInstance(result, ErrorResponse)
         self.assertIn("Server error", result.error_message)
 
     def test_get_tables_all_schemas(self):
         """Test get_tables with all=True."""
-        self.handler.native_query = MagicMock(
-            return_value=Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame([{"table_name": "t1"}]))
-        )
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=pd.DataFrame([{"table_name": "t1"}])))
 
         self.handler.get_tables(all=True)
 
@@ -276,7 +294,7 @@ def test_get_columns_with_schema(self):
             ]
         )
 
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=mock_df))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=mock_df))
 
         self.handler.get_columns("test_table", schema_name="my_schema")
 
@@ -415,7 +433,7 @@ def test_query_transforms_date_add_day_interval(self):
         """Test DATE_ADD with INTERVAL DAY is transformed to integer argument."""
         query = parse_sql("SELECT DATE_ADD(o_orderdate, INTERVAL '30' DAY) AS due_date FROM orders LIMIT 1")
         # breakpoint()
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -426,7 +444,7 @@ def test_query_transforms_date_add_day_interval(self):
     def test_query_transforms_date_add_days_plural(self):
         """Test DATE_ADD with INTERVAL DAYS (plural) is transformed correctly."""
         query = parse_sql("SELECT DATE_ADD(o_orderdate, INTERVAL 7 DAYS) AS due_date FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -437,7 +455,7 @@ def test_query_transforms_date_add_days_plural(self):
     def test_query_transforms_date_sub_day_interval(self):
         """Test DATE_SUB with INTERVAL DAY is transformed to integer argument."""
         query = parse_sql("SELECT DATE_SUB(o_orderdate, INTERVAL '5' DAY) AS past_date FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -448,7 +466,7 @@ def test_query_transforms_date_sub_day_interval(self):
     def test_query_transforms_date_add_week_interval(self):
         """Test DATE_ADD with INTERVAL WEEK is converted to days."""
         query = parse_sql("SELECT DATE_ADD(o_orderdate, INTERVAL '2' WEEK) AS future_date FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -459,7 +477,7 @@ def test_query_transforms_date_add_week_interval(self):
     def test_query_transforms_date_sub_week_interval(self):
         """Test DATE_SUB with INTERVAL WEEK is converted to days."""
         query = parse_sql("SELECT DATE_SUB(o_orderdate, INTERVAL '2' WEEK) AS past_date FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -470,7 +488,7 @@ def test_query_transforms_date_sub_week_interval(self):
     def test_query_transforms_date_add_month_interval(self):
         """Test DATE_ADD with INTERVAL MONTH uses ADD_MONTHS function."""
         query = parse_sql("SELECT DATE_ADD(o_orderdate, INTERVAL '2' MONTH) AS future_date FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -481,7 +499,7 @@ def test_query_transforms_date_add_month_interval(self):
     def test_query_transforms_date_sub_month_interval(self):
         """Test DATE_SUB with INTERVAL MONTH uses ADD_MONTHS with negative value."""
         query = parse_sql("SELECT DATE_SUB(o_orderdate, INTERVAL '3' MONTH) AS past_date FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -492,7 +510,7 @@ def test_query_transforms_date_sub_month_interval(self):
     def test_query_transforms_date_add_year_interval(self):
         """Test DATE_ADD with INTERVAL YEAR uses ADD_MONTHS with 12x multiplier."""
         query = parse_sql("SELECT DATE_ADD(o_orderdate, INTERVAL '1' YEAR) AS future_date FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -503,7 +521,7 @@ def test_query_transforms_date_add_year_interval(self):
     def test_query_transforms_date_sub_year_interval(self):
         """Test DATE_SUB with INTERVAL YEAR uses ADD_MONTHS with negative 12x value."""
         query = parse_sql("SELECT DATE_SUB(o_orderdate, INTERVAL '2' YEAR) AS past_date FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -514,7 +532,7 @@ def test_query_transforms_date_sub_year_interval(self):
     def test_query_transforms_date_add_hour_interval(self):
         """Test DATE_ADD with INTERVAL HOUR uses TIMESTAMPADD function."""
         query = parse_sql("SELECT DATE_ADD(o_orderdate, INTERVAL '6' HOUR) AS future_time FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -525,7 +543,7 @@ def test_query_transforms_date_add_hour_interval(self):
     def test_query_transforms_date_sub_hour_interval(self):
         """Test DATE_SUB with INTERVAL HOUR uses TIMESTAMPADD with negative value."""
         query = parse_sql("SELECT DATE_SUB(o_orderdate, INTERVAL '3' HOUR) AS past_time FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -536,7 +554,7 @@ def test_query_transforms_date_sub_hour_interval(self):
     def test_query_transforms_date_add_minute_interval(self):
         """Test DATE_ADD with INTERVAL MINUTE uses TIMESTAMPADD function."""
         query = parse_sql("SELECT DATE_ADD(o_orderdate, INTERVAL '30' MINUTE) AS future_time FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -547,7 +565,7 @@ def test_query_transforms_date_add_minute_interval(self):
     def test_query_transforms_date_add_second_interval(self):
         """Test DATE_ADD with INTERVAL SECOND uses TIMESTAMPADD function."""
         query = parse_sql("SELECT DATE_ADD(o_orderdate, INTERVAL '45' SECOND) AS future_time FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -558,7 +576,7 @@ def test_query_transforms_date_add_second_interval(self):
     def test_query_without_interval_unchanged(self):
         """Test that queries without INTERVAL pass through unchanged."""
         query = parse_sql("SELECT DATE_ADD(o_orderdate, 10) AS future_date FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -569,7 +587,7 @@ def test_query_without_interval_unchanged(self):
     def test_query_transforms_date_add_quarter_interval(self):
         """Test DATE_ADD with INTERVAL QUARTER uses ADD_MONTHS with 3x multiplier."""
         query = parse_sql("SELECT DATE_ADD(o_orderdate, INTERVAL '2' QUARTER) AS future_date FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -580,7 +598,7 @@ def test_query_transforms_date_add_quarter_interval(self):
     def test_query_transforms_date_sub_quarter_interval(self):
         """Test DATE_SUB with INTERVAL QUARTER uses ADD_MONTHS with negative 3x value."""
         query = parse_sql("SELECT DATE_SUB(o_orderdate, INTERVAL '1' QUARTER) AS past_date FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -591,7 +609,7 @@ def test_query_transforms_date_sub_quarter_interval(self):
     def test_query_transforms_date_sub_minute_interval(self):
         """Test DATE_SUB with INTERVAL MINUTE uses TIMESTAMPADD with negative value."""
         query = parse_sql("SELECT DATE_SUB(o_orderdate, INTERVAL '15' MINUTE) AS past_time FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
@@ -602,7 +620,7 @@ def test_query_transforms_date_sub_minute_interval(self):
     def test_query_transforms_date_sub_second_interval(self):
         """Test DATE_SUB with INTERVAL SECOND uses TIMESTAMPADD with negative value."""
         query = parse_sql("SELECT DATE_SUB(o_orderdate, INTERVAL '30' SECOND) AS past_time FROM orders")
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.OK))
+        self.handler.native_query = MagicMock(return_value=OkResponse())
 
         self.handler.query(query)
 
diff --git a/tests/unit/handlers/test_dynamodb.py b/tests/unit/handlers/test_dynamodb.py
index f1aef2481b1..6811afa40e7 100644
--- a/tests/unit/handlers/test_dynamodb.py
+++ b/tests/unit/handlers/test_dynamodb.py
@@ -8,29 +8,24 @@
 from mindsdb_sql_parser.ast.select.identifier import Identifier
 
 from base_handler_test import BaseHandlerTestSetup
-from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response,
-    HandlerStatusResponse as StatusResponse,
-    RESPONSE_TYPE
-)
+from mindsdb.integrations.libs.response import TableResponse, HandlerStatusResponse as StatusResponse, RESPONSE_TYPE
 from mindsdb.integrations.handlers.dynamodb_handler.dynamodb_handler import DynamoDBHandler
 
 
 class TestDynamoDBHandler(BaseHandlerTestSetup, unittest.TestCase):
-
     @property
     def dummy_connection_data(self):
         return OrderedDict(
-            aws_access_key_id='AQAXEQK89OX07YS34OP',
-            aws_secret_access_key='wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-            region_name='us-east-2',
+            aws_access_key_id="AQAXEQK89OX07YS34OP",
+            aws_secret_access_key="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+            region_name="us-east-2",
         )
 
     def create_handler(self):
-        return DynamoDBHandler('dynamodb', connection_data=self.dummy_connection_data)
+        return DynamoDBHandler("dynamodb", connection_data=self.dummy_connection_data)
 
     def create_patcher(self):
-        return patch('boto3.client')
+        return patch("boto3.client")
 
     def test_connect_failure_with_missing_connection_data(self):
         """
@@ -58,8 +53,8 @@ def test_check_connection_failure_with_incorrect_credentials(self):
         Test if the `check_connection` method returns a StatusResponse object and accurately reflects the connection status on failed connection due to incorrect credentials.
         """
         self.mock_connect.return_value.list_tables.side_effect = ClientError(
-            error_response={'Error': {'Code': 'AccessDeniedException', 'Message': 'Access Denied'}},
-            operation_name='list_tables'
+            error_response={"Error": {"Code": "AccessDeniedException", "Message": "Access Denied"}},
+            operation_name="list_tables",
         )
 
         response = self.handler.check_connection()
@@ -72,7 +67,7 @@ def test_check_connection_success(self):
         """
         Test if the `check_connection` method returns a StatusResponse object and accurately reflects the connection status on a successful connection.
         """
-        self.mock_connect.return_value.list_tables.return_value = {'TableNames': ['table1', 'table2']}
+        self.mock_connect.return_value.list_tables.return_value = {"TableNames": ["table1", "table2"]}
         response = self.handler.check_connection()
 
         self.assertTrue(response.success)
@@ -81,15 +76,12 @@ def test_check_connection_success(self):
 
     def test_query_select_success(self):
         """
-        Test if the `query` method returns a response object with a data frame containing the query result.
+        Test if the `query` method returns a TableResponse object with a data frame containing the query result.
         `native_query` cannot be tested directly because it depends on some pre-processing steps handled by the `query` method.
         """
         mock_boto3_client = Mock()
         mock_boto3_client.execute_statement.return_value = {
-            'Items': [
-                {'id': {'N': '1'}, 'name': {'S': 'Alice'}},
-                {'id': {'N': '2'}, 'name': {'S': 'Bob'}}
-            ]
+            "Items": [{"id": {"N": "1"}, "name": {"S": "Alice"}}, {"id": {"N": "2"}, "name": {"S": "Bob"}}]
         }
 
         self.handler.connect = MagicMock(return_value=mock_boto3_client)
@@ -97,18 +89,18 @@ def test_query_select_success(self):
             targets=[
                 Star(),
             ],
-            from_table=ast.Identifier('table1')
+            from_table=ast.Identifier("table1"),
         )
         response = self.handler.query(query)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
         self.assertEqual(len(df), 2)
-        self.assertEqual(df.columns.tolist(), ['id', 'name'])
-        self.assertEqual(df['id'].tolist(), [1, 2])
-        self.assertEqual(df['name'].tolist(), ['Alice', 'Bob'])
+        self.assertEqual(df.columns.tolist(), ["id", "name"])
+        self.assertEqual(df["id"].tolist(), [1, 2])
+        self.assertEqual(df["name"].tolist(), ["Alice", "Bob"])
 
     def test_query_select_failure_with_unsupported_clause(self):
         """
@@ -118,8 +110,8 @@ def test_query_select_failure_with_unsupported_clause(self):
             targets=[
                 Star(),
             ],
-            from_table=ast.Identifier('table1'),
-            limit=10
+            from_table=ast.Identifier("table1"),
+            limit=10,
         )
         with self.assertRaises(ValueError):
             self.handler.query(query)
@@ -132,62 +124,58 @@ def test_query_insert_failure(self):
         mock_boto3_client.execute_statement.return_value = {}
 
         self.handler.connect = MagicMock(return_value=mock_boto3_client)
-        query = ast.Insert(
-            table=Identifier('table1'),
-            columns=['id', 'name'],
-            values=[[1, 'Alice']]
-        )
+        query = ast.Insert(table=Identifier("table1"), columns=["id", "name"], values=[[1, "Alice"]])
         with self.assertRaises(ValueError):
             self.handler.query(query)
 
     def test_get_tables(self):
         """
-        Test if the `get_tables` method returns a response object with a list of tables.
+        Test if the `get_tables` method returns a TableResponse object with a list of tables.
         """
         mock_boto3_client = Mock()
-        mock_boto3_client.list_tables.return_value = {'TableNames': ['table1', 'table2']}
+        mock_boto3_client.list_tables.return_value = {"TableNames": ["table1", "table2"]}
 
         self.handler.connection = mock_boto3_client
         response = self.handler.get_tables()
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
         self.assertEqual(len(df), 2)
-        self.assertEqual(df.columns.tolist(), ['table_name'])
-        self.assertEqual(df['table_name'].tolist(), ['table1', 'table2'])
+        self.assertEqual(df.columns.tolist(), ["table_name"])
+        self.assertEqual(df["table_name"].tolist(), ["table1", "table2"])
 
     def test_get_columns(self):
         """
-        Test if the `get_columns` method returns a response object with a list of columns for a given table.
+        Test if the `get_columns` method returns a TableResponse object with a list of columns for a given table.
         """
         mock_boto3_client = Mock()
         mock_boto3_client.describe_table.return_value = {
-            'Table': {
-                'KeySchema': [
-                    {'AttributeName': 'id', 'KeyType': 'HASH'},
-                    {'AttributeName': 'name', 'KeyType': 'RANGE'}
+            "Table": {
+                "KeySchema": [
+                    {"AttributeName": "id", "KeyType": "HASH"},
+                    {"AttributeName": "name", "KeyType": "RANGE"},
+                ],
+                "AttributeDefinitions": [
+                    {"AttributeName": "id", "AttributeType": "N"},
+                    {"AttributeName": "name", "AttributeType": "S"},
                 ],
-                'AttributeDefinitions': [
-                    {'AttributeName': 'id', 'AttributeType': 'N'},
-                    {'AttributeName': 'name', 'AttributeType': 'S'}
-                ]
             }
         }
 
         self.handler.connection = mock_boto3_client
-        response = self.handler.get_columns('table1')
+        response = self.handler.get_columns("table1")
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
         self.assertEqual(len(df), 2)
-        self.assertEqual(df.columns.tolist(), ['column_name', 'data_type'])
-        self.assertEqual(df['column_name'].tolist(), ['id', 'name'])
-        self.assertEqual(df['data_type'].tolist(), ['N', 'S'])
+        self.assertEqual(df.columns.tolist(), ["column_name", "data_type"])
+        self.assertEqual(df["column_name"].tolist(), ["id", "name"])
+        self.assertEqual(df["data_type"].tolist(), ["N", "S"])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()
diff --git a/tests/unit/handlers/test_file.py b/tests/unit/handlers/test_file.py
index 9df2ee28415..7c54c8cbbc7 100644
--- a/tests/unit/handlers/test_file.py
+++ b/tests/unit/handlers/test_file.py
@@ -17,8 +17,8 @@
 )
 
 from mindsdb.integrations.handlers.file_handler.file_handler import FileHandler
-from mindsdb.integrations.libs.response import RESPONSE_TYPE
-
+from mindsdb.integrations.libs.response import RESPONSE_TYPE, INF_SCHEMA_COLUMNS_NAMES_SET, INF_SCHEMA_COLUMNS_NAMES
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 from mindsdb.integrations.utilities.files.file_reader import (
     FileReader,
     FileProcessingError,
@@ -406,8 +406,25 @@ def test_get_columns():
     file_handler = FileHandler(file_controller=MockFileController())
     response = file_handler.get_columns("mock")
 
-    assert response.type == RESPONSE_TYPE.TABLE
-
-    expected_df = pandas.DataFrame([{"Field": x, "Type": "str"} for x in file_records[0][2]])
-
-    assert response.data_frame.equals(expected_df)
+    assert response.type == RESPONSE_TYPE.COLUMNS_TABLE
+
+    data = []
+    for name in file_records[0][2]:
+        row = {}
+        for key_name in INF_SCHEMA_COLUMNS_NAMES_SET:
+            if key_name == INF_SCHEMA_COLUMNS_NAMES.COLUMN_NAME:
+                row[key_name] = name
+            elif key_name == INF_SCHEMA_COLUMNS_NAMES.DATA_TYPE:
+                row[key_name] = "str"
+            elif key_name == INF_SCHEMA_COLUMNS_NAMES.MYSQL_DATA_TYPE:
+                row[key_name] = MYSQL_DATA_TYPE.TEXT
+            else:
+                row[key_name] = None
+        data.append(row)
+
+    expected_df = pandas.DataFrame(data)
+    assert set(response.data_frame.columns) == set(expected_df.columns)
+    expected_df = expected_df[response.data_frame.columns]
+
+    # Use 'compare' to ignore dtypes (object != string)
+    assert response.data_frame.compare(expected_df).empty
diff --git a/tests/unit/handlers/test_jira.py b/tests/unit/handlers/test_jira.py
new file mode 100644
index 00000000000..dd1e4d8f6a0
--- /dev/null
+++ b/tests/unit/handlers/test_jira.py
@@ -0,0 +1,397 @@
+import pytest
+import unittest
+
+from unittest.mock import patch, MagicMock
+from requests.exceptions import HTTPError
+
+import pandas as pd
+
+
+from base_handler_test import BaseHandlerTestSetup
+from mindsdb.integrations.libs.response import (
+    HandlerResponse as Response,
+    HandlerStatusResponse as StatusResponse,
+    RESPONSE_TYPE,
+)
+
+try:
+    from mindsdb.integrations.handlers.jira_handler.jira_handler import JiraHandler
+    from mindsdb.integrations.handlers.jira_handler.jira_tables import (
+        JiraAttachmentsTable,
+        JiraCommentsTable,
+        JiraIssuesTable,
+        JiraUsersTable,
+        JiraProjectsTable,
+        JiraGroupsTable,
+        SERVER_COLUMNS,
+    )
+except ImportError:
+    pytestmark = pytest.mark.skip("Jira handler not installed")
+
+
+class TestJiraHandler(BaseHandlerTestSetup, unittest.TestCase):
+    @property
+    def dummy_connection_data(self):
+        return {
+            "jira_url": "https://your-domain.atlassian.net",
+            "jira_username": "username",
+            "jira_api_token": "your_api_token",
+            "is_cloud": False,
+        }
+
+    @property
+    def err_to_raise_on_connect_failure(self):
+        return HTTPError("Failed to connect to Jira")
+
+    def create_handler(self):
+        return JiraHandler("jira", self.dummy_connection_data)
+
+    def create_patcher(self):
+        return patch("mindsdb.integrations.handlers.jira_handler.jira_handler.Jira")
+
+    def test_connect_cloud_success(self):
+        """Ensure cloud connections normalize credentials and reuse Jira constructor correctly."""
+        mock_client = MagicMock()
+        self.mock_connect.return_value = mock_client
+
+        connection = self.handler.connect()
+
+        self.assertIs(connection, mock_client)
+        self.assertTrue(self.handler.is_connected)
+        self.mock_connect.assert_called_once_with(
+            username=self.dummy_connection_data["jira_username"],
+            password=self.dummy_connection_data["jira_api_token"],
+            url=self.dummy_connection_data["jira_url"],
+            cloud=True,
+        )
+
+    def test_connect_reuse_existing_connection(self):
+        """If already connected, connect should reuse the existing client."""
+        cached_connection = MagicMock()
+        self.handler.connection = cached_connection
+        self.handler.is_connected = True
+
+        connection = self.handler.connect()
+
+        self.assertIs(connection, cached_connection)
+        self.mock_connect.assert_not_called()
+
+    def test_connect_runtime_error_on_missing_cached_connection(self):
+        """Marking the handler as connected without a cached client should raise."""
+        self.handler.is_connected = True
+        self.handler.connection = None
+
+        with self.assertRaises(RuntimeError):
+            self.handler.connect()
+
+    def test_check_connection_http_error(self):
+        """check_connection should surface HTTP errors from the Jira client."""
+        mock_client = MagicMock()
+        mock_client.myself.side_effect = HTTPError("Unauthorized")
+        self.mock_connect.return_value = mock_client
+
+        response = self.handler.check_connection()
+
+        assert isinstance(response, StatusResponse)
+        self.assertFalse(response.success)
+        self.assertIn("Unauthorized", response.error_message)
+        self.assertFalse(self.handler.is_connected)
+
+    def test_native_query_http_error(self):
+        """native_query should return an error response when Jira raises HTTPError."""
+        mock_client = MagicMock()
+        mock_client.jql.side_effect = HTTPError("Bad JQL")
+        self.mock_connect.return_value = mock_client
+
+        response = self.handler.native_query("project = TEST")
+
+        assert isinstance(response, Response)
+        self.assertEqual(response.type, RESPONSE_TYPE.ERROR)
+        self.assertIn("Bad JQL", response.error_message)
+
+    def test_native_query_returns_empty_dataframe_when_no_issues(self):
+        """Ensure native_query returns an empty dataframe with expected columns."""
+        mock_client = MagicMock()
+        mock_client.jql.return_value = {}
+        self.mock_connect.return_value = mock_client
+
+        response = self.handler.native_query("project = TEST")
+
+        assert isinstance(response, Response)
+        self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
+        self.assertTrue(response.data_frame.empty)
+        issues_columns = JiraIssuesTable(self.handler).get_columns()
+        self.assertListEqual(list(response.data_frame.columns), issues_columns)
+
+    def test_attachments_table_fetches_missing_fields(self):
+        """Attachments table should refresh issues to retrieve missing attachment fields."""
+        mock_client = MagicMock()
+        self.mock_connect.return_value = mock_client
+
+        issue_without_attachments = {"id": "1", "key": "ISSUE-1", "fields": {}}
+        mock_client.get_all_projects.return_value = [{"id": "100"}]
+        mock_client.get_all_project_issues.return_value = [issue_without_attachments]
+        mock_client.get_issue.return_value = {
+            "fields": {"attachment": [{"id": "att-1", "filename": "log.txt", "size": 10, "mimeType": "text/plain"}]}
+        }
+
+        attachments_table = JiraAttachmentsTable(self.handler)
+        result_df = attachments_table.list(limit=1)
+
+        self.assertEqual(len(result_df), 1)
+        self.assertEqual(result_df.loc[0, "attachment_id"], "att-1")
+        self.assertEqual(result_df.loc[0, "issue_key"], "ISSUE-1")
+        self.assertEqual(result_df.loc[0, "filename"], "log.txt")
+
+    def test_issues_table_missing_assignee(self):
+        """Test that issues without assignee are handled correctly."""
+        mock_client = MagicMock()
+        self.mock_connect.return_value = mock_client
+
+        mock_issues = [
+            {
+                "id": "1",
+                "key": "TEST-1",
+                "fields": {
+                    "project": {"id": "10001", "key": "TEST", "name": "Test Project"},
+                    "summary": "Issue with assignee",
+                    "priority": {"name": "High"},
+                    "creator": {"displayName": "John Doe"},
+                    "assignee": {"displayName": "Jane Smith"},
+                    "status": {"name": "In Progress"},
+                },
+            },
+            {
+                "id": "2",
+                "key": "TEST-2",
+                "fields": {
+                    "project": {"id": "10001", "key": "TEST", "name": "Test Project"},
+                    "summary": "Unassigned issue",
+                    "priority": {"name": "Medium"},
+                    "creator": {"displayName": "John Doe"},
+                    "status": {"name": "Open"},
+                },
+            },
+            {
+                "id": "3",
+                "key": "TEST-3",
+                "fields": {
+                    "project": {"id": "10001", "key": "TEST", "name": "Test Project"},
+                    "summary": "Issue without priority",
+                    "creator": {"displayName": "John Doe"},
+                    "status": {"name": "Done"},
+                },
+            },
+        ]
+
+        mock_client.get_all_projects.return_value = [{"id": "10001"}]
+        mock_client.get_all_project_issues.return_value = mock_issues
+
+        issues_table = JiraIssuesTable(self.handler)
+        result_df = issues_table.list(conditions=[])
+
+        self.assertEqual(len(result_df), 3)
+        self.assertIsNotNone(result_df)
+
+        expected_columns = issues_table.get_columns()
+        for col in expected_columns:
+            self.assertIn(col, result_df.columns)
+
+        self.assertEqual(result_df.loc[0, "assignee"], "Jane Smith")
+        self.assertTrue(pd.isna(result_df.loc[1, "assignee"]))
+        self.assertTrue(pd.isna(result_df.loc[2, "assignee"]))
+
+        self.assertEqual(result_df.loc[0, "priority"], "High")
+        self.assertEqual(result_df.loc[1, "priority"], "Medium")
+        self.assertTrue(pd.isna(result_df.loc[2, "priority"]))
+
+    def test_users_table_missing_timezone(self):
+        """Test that users without timeZone field are handled correctly."""
+        mock_client = MagicMock()
+        self.mock_connect.return_value = mock_client
+
+        mock_users = [
+            {
+                "accountId": "user1",
+                "accountType": "atlassian",
+                "emailAddress": "user1@example.com",
+                "displayName": "User One",
+                "active": True,
+                "timeZone": "America/New_York",
+                "locale": "en_US",
+            },
+            {
+                "accountId": "user2",
+                "accountType": "atlassian",
+                "emailAddress": "user2@example.com",
+                "displayName": "User Two",
+                "active": True,
+                "locale": "en_US",
+            },
+            {
+                "accountId": "user3",
+                "accountType": "atlassian",
+                "displayName": "User Three",
+                "active": False,
+            },
+        ]
+
+        mock_client.users_get_all.return_value = mock_users
+
+        users_table = JiraUsersTable(self.handler)
+        result_df = users_table.list(conditions=[])
+
+        self.assertEqual(len(result_df), 3)
+        self.assertIsNotNone(result_df)
+
+        expected_columns = users_table.get_columns()
+        for col in expected_columns:
+            self.assertIn(col, result_df.columns)
+
+        self.assertEqual(result_df.loc[0, "timeZone"], "America/New_York")
+        self.assertTrue(pd.isna(result_df.loc[1, "timeZone"]))
+        self.assertTrue(pd.isna(result_df.loc[2, "timeZone"]))
+
+        self.assertEqual(result_df.loc[0, "emailAddress"], "user1@example.com")
+        self.assertEqual(result_df.loc[1, "emailAddress"], "user2@example.com")
+        self.assertTrue(pd.isna(result_df.loc[2, "emailAddress"]))
+
+    def test_projects_table_missing_optional_fields(self):
+        """Test that projects with missing optional fields are handled correctly."""
+        mock_client = MagicMock()
+        self.mock_connect.return_value = mock_client
+
+        mock_projects = [
+            {
+                "id": "10001",
+                "key": "PROJ1",
+                "name": "Project One",
+                "projectTypeKey": "software",
+                "simplified": True,
+                "style": "classic",
+                "isPrivate": False,
+                "entityId": "entity1",
+                "uuid": "uuid1",
+            },
+            {
+                "id": "10002",
+                "key": "PROJ2",
+                "name": "Project Two",
+            },
+        ]
+
+        mock_client.get_all_projects.return_value = mock_projects
+
+        projects_table = JiraProjectsTable(self.handler)
+        result_df = projects_table.list(conditions=[])
+
+        self.assertEqual(len(result_df), 2)
+        self.assertIsNotNone(result_df)
+
+        expected_columns = projects_table.get_columns()
+        for col in expected_columns:
+            self.assertIn(col, result_df.columns)
+
+        self.assertEqual(result_df.loc[0, "projectTypeKey"], "software")
+        self.assertTrue(pd.isna(result_df.loc[1, "projectTypeKey"]))
+
+    def test_groups_table_missing_fields(self):
+        """Test that groups with missing fields are handled correctly."""
+        mock_client = MagicMock()
+        self.mock_connect.return_value = mock_client
+
+        mock_groups = {
+            "groups": [
+                {
+                    "groupId": "group1",
+                    "name": "Developers",
+                    "html": "<a>Developers</a>",
+                },
+                {
+                    "groupId": "group2",
+                    "name": "Managers",
+                },
+            ]
+        }
+
+        mock_client.get_groups.return_value = mock_groups
+
+        groups_table = JiraGroupsTable(self.handler)
+        result_df = groups_table.list(conditions=[])
+
+        self.assertEqual(len(result_df), 2)
+        self.assertIsNotNone(result_df)
+
+        expected_columns = groups_table.get_columns()
+        for col in expected_columns:
+            self.assertIn(col, result_df.columns)
+
+        self.assertEqual(result_df.loc[0, "html"], "<a>Developers</a>")
+        self.assertTrue(pd.isna(result_df.loc[1, "html"]))
+
+    def test_comments_table_fetches_missing_fields(self):
+        """Comments table should refresh issues to retrieve missing comment fields."""
+        mock_client = MagicMock()
+        self.mock_connect.return_value = mock_client
+
+        issue_without_comments = {"id": "1", "key": "ISSUE-1", "fields": {}}
+        mock_client.get_all_projects.return_value = [{"id": "100"}]
+        mock_client.get_all_project_issues.return_value = [issue_without_comments]
+        mock_client.get_issue.return_value = {
+            "fields": {
+                "comment": {
+                    "comments": [
+                        {
+                            "id": "c-1",
+                            "body": "First comment",
+                            "created": "2024-01-01",
+                            "updated": "2024-01-02",
+                            "author": {
+                                "displayName": "Commenter",
+                                "accountId": "acc-1",
+                            },
+                            "visibility": {
+                                "type": "role",
+                                "value": "admin",
+                            },
+                        }
+                    ]
+                }
+            }
+        }
+
+        comments_table = JiraCommentsTable(self.handler)
+        result_df = comments_table.list(limit=1)
+
+        self.assertEqual(len(result_df), 1)
+        self.assertEqual(result_df.loc[0, "comment_id"], "c-1")
+        self.assertEqual(result_df.loc[0, "issue_key"], "ISSUE-1")
+        self.assertEqual(result_df.loc[0, "body"], "First comment")
+        self.assertEqual(result_df.loc[0, "author"], "Commenter")
+        self.assertEqual(result_df.loc[0, "visibility_type"], "role")
+        self.assertEqual(result_df.loc[0, "visibility_value"], "admin")
+
+    def test_users_table_server_mode_columns(self):
+        """Users table should switch to server columns when client.cloud is False."""
+        mock_client = MagicMock()
+        mock_client.cloud = False
+        self.mock_connect.return_value = mock_client
+
+        mock_client.user.return_value = {
+            "name": "serveruser",
+            "displayName": "Server User",
+            "emailAddress": "server@example.com",
+        }
+
+        users_table = JiraUsersTable(self.handler)
+        result_df = users_table.list()
+
+        self.assertEqual(len(result_df), 1)
+        self.assertListEqual(list(result_df.columns), SERVER_COLUMNS)
+        self.assertEqual(result_df.loc[0, "name"], "serveruser")
+        self.assertEqual(result_df.loc[0, "displayName"], "Server User")
+        self.assertEqual(result_df.loc[0, "emailAddress"], "server@example.com")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/unit/handlers/test_mariadb.py b/tests/unit/handlers/test_mariadb.py
index be2cc4f6120..9d75a8dce72 100644
--- a/tests/unit/handlers/test_mariadb.py
+++ b/tests/unit/handlers/test_mariadb.py
@@ -6,19 +6,18 @@
 
 from base_handler_test import BaseDatabaseHandlerTest, MockCursorContextManager
 from mindsdb.integrations.handlers.mariadb_handler.mariadb_handler import MariaDBHandler
-from mindsdb.integrations.libs.response import HandlerResponse as Response
+from mindsdb.integrations.libs.response import TableResponse
 
 
 class TestMariaDBHandler(BaseDatabaseHandlerTest, unittest.TestCase):
-
     @property
     def dummy_connection_data(self):
         return OrderedDict(
-            host='127.0.0.1',
+            host="127.0.0.1",
             port=3307,
-            user='example_user',
-            password='example_pass',
-            database='example_db',
+            user="example_user",
+            password="example_pass",
+            database="example_db",
         )
 
     @property
@@ -60,22 +59,21 @@ def get_columns_query(self):
             from
                 information_schema.columns
             where
-                table_name = '{self.mock_table}';
+                table_name = '{self.mock_table}'
+                and table_schema = DATABASE();
         """
 
     def create_handler(self):
-        return MariaDBHandler('mariadb', connection_data=self.dummy_connection_data)
+        return MariaDBHandler("mariadb", connection_data=self.dummy_connection_data)
 
     def create_patcher(self):
-        return patch('mysql.connector.connect')
+        return patch("mysql.connector.connect")
 
     def test_native_query(self):
-        """Test that native_query returns a Response object with no error
-        """
+        """Test that native_query returns a TableResponse object with no error"""
         mock_conn = MagicMock()
         mock_cursor = MockCursorContextManager(
-            data=[{'id': 1}],
-            description=[('id', 3, None, None, None, None, 1, 0, 45)]
+            data=[{"id": 1}], description=[("id", 3, None, None, None, None, 1, 0, 45)]
         )
 
         self.handler.connect = MagicMock(return_value=mock_conn)
@@ -84,9 +82,8 @@ def test_native_query(self):
         query_str = f"SELECT * FROM {self.mock_table}"
         data = self.handler.native_query(query_str)
 
-        self.assertIsInstance(data, Response)
-        self.assertFalse(data.error_code)
+        self.assertIsInstance(data, TableResponse)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()
diff --git a/tests/unit/handlers/test_mongodb.py b/tests/unit/handlers/test_mongodb.py
index 36ae12c8479..1939fdb6342 100644
--- a/tests/unit/handlers/test_mongodb.py
+++ b/tests/unit/handlers/test_mongodb.py
@@ -11,7 +11,9 @@
 
 from base_handler_test import BaseHandlerTestSetup
 from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response,
+    TableResponse,
+    OkResponse,
+    ErrorResponse,
     HandlerStatusResponse as StatusResponse,
     RESPONSE_TYPE,
 )
@@ -88,7 +90,7 @@ def test_check_connection_success(self):
 
     def test_query_failure_with_non_existent_collection(self):
         """
-        Test if the `query` method returns a response object with an error message on failed query due to non-existent collection.
+        Test if the `query` method returns an ErrorResponse object with an error message on failed query due to non-existent collection.
         """
         self.mock_connect.return_value[self.dummy_connection_data["database"]].list_collection_names.return_value = [
             "movies"
@@ -103,7 +105,7 @@ def test_query_failure_with_non_existent_collection(self):
 
         response = self.handler.query(query)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, ErrorResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.ERROR)
         self.assertTrue(response.error_message)
 
@@ -139,7 +141,7 @@ def test_query_failure_with_unsupported_operation(self):
 
     def test_query_select_success(self):
         """
-        Test if the `query` method returns a response object with a data frame containing the query result.
+        Test if the `query` method returns a TableResponse object with a data frame containing the query result.
         `native_query` cannot be tested directly because it depends on some pre-processing steps handled by the `query` method.
         """
         self.mock_connect.return_value[self.dummy_connection_data["database"]].list_collection_names.return_value = [
@@ -164,7 +166,7 @@ def test_query_select_success(self):
 
         response = self.handler.query(query)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -174,7 +176,7 @@ def test_query_select_success(self):
 
     def test_query_update_success(self):
         """
-        Test if the `query` method returns a response object with a 'OK' status.
+        Test if the `query` method returns an OkResponse object with a 'OK' status.
         `native_query` cannot be tested directly because it depends on some pre-processing steps handled by the `query` method.
         """
         self.mock_connect.return_value[self.dummy_connection_data["database"]].list_collection_names.return_value = [
@@ -201,12 +203,12 @@ def test_query_update_success(self):
 
         response = self.handler.query(query)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, OkResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.OK)
 
     def test_get_tables(self):
         """
-        Tests the `get_tables` method returns a response object with a list of tables (collections) in the database.
+        Tests the `get_tables` method returns a TableResponse object with a list of tables (collections) in the database.
         """
         self.mock_connect.return_value[self.dummy_connection_data["database"]].list_collection_names.return_value = [
             "theaters",
@@ -219,7 +221,7 @@ def test_get_tables(self):
 
         response = self.handler.get_tables()
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -232,7 +234,7 @@ def test_get_tables(self):
 
     def test_get_columns(self):
         """
-        Tests the `get_columns` method returns a response object with a list of columns (fields) for a given table (collection).
+        Tests the `get_columns` method returns a TableResponse object with a list of columns (fields) for a given table (collection).
         """
         self.mock_connect.return_value[self.dummy_connection_data["database"]]["movies"].find_one.return_value = {
             "_id": ObjectId("5f5b3f3b3f3b3f3b3f3b3f3b"),
@@ -243,7 +245,7 @@ def test_get_columns(self):
 
         response = self.handler.get_columns("movies")
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -287,7 +289,7 @@ def test_query_select_with_subquery_success(self):
 
         response = self.handler.query(main_query)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -353,7 +355,7 @@ def test_query_select_with_complex_subquery_success(self):
 
         response = self.handler.query(main_query)
 
-        self.assertIsInstance(response, Response)
+        self.assertIsInstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -388,7 +390,7 @@ def test_query_select_with_where_operators(self):
 
         response = self.handler.query(query)
 
-        self.assertIsInstance(response, Response)
+        self.assertIsInstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -431,7 +433,7 @@ def test_query_select_with_and_or_conditions(self):
 
         response = self.handler.query(query)
 
-        self.assertIsInstance(response, Response)
+        self.assertIsInstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -494,7 +496,7 @@ def test_select_with_match_and_projection(self):
 
         response = self.handler.query(query)
 
-        self.assertIsInstance(response, Response)
+        self.assertIsInstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -525,7 +527,7 @@ def test_select_constant_with_alias(self):
 
         response = self.handler.query(query)
 
-        self.assertIsInstance(response, Response)
+        self.assertIsInstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -557,7 +559,7 @@ def test_select_with_constant_no_alias(self):
 
         response = self.handler.query(query)
 
-        self.assertIsInstance(response, Response)
+        self.assertIsInstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -604,7 +606,7 @@ def test_query_select_with_subquery_and_where(self):
 
         response = self.handler.query(main_query)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -643,7 +645,7 @@ def test_query_select_nested_field_projection(self):
 
         response = self.handler.query(query)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -689,7 +691,7 @@ def test_query_select_nested_field_with_where(self):
 
         response = self.handler.query(query)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -725,7 +727,7 @@ def test_query_aggregation_on_nested_field(self):
 
         response = self.handler.query(query)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -772,7 +774,7 @@ def test_query_group_by_with_nested_aggregation(self):
 
         response = self.handler.query(query)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
diff --git a/tests/unit/handlers/test_mssql.py b/tests/unit/handlers/test_mssql.py
index dbb097754f9..d7024d51359 100644
--- a/tests/unit/handlers/test_mssql.py
+++ b/tests/unit/handlers/test_mssql.py
@@ -17,7 +17,13 @@
 from pandas import DataFrame
 
 from base_handler_test import BaseDatabaseHandlerTest
-from mindsdb.integrations.libs.response import HandlerResponse as Response, INF_SCHEMA_COLUMNS_NAMES_SET, RESPONSE_TYPE
+from mindsdb.integrations.libs.response import (
+    OkResponse,
+    TableResponse,
+    ErrorResponse,
+    INF_SCHEMA_COLUMNS_NAMES_SET,
+    RESPONSE_TYPE,
+)
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 
@@ -91,8 +97,7 @@ def test_native_query_with_results(self):
         mock_conn.cursor.assert_called_once_with(as_dict=True)
         mock_cursor.execute.assert_called_once_with(query_str)
 
-        assert isinstance(data, Response)
-        self.assertFalse(data.error_code)
+        assert isinstance(data, TableResponse)
         self.assertEqual(data.type, RESPONSE_TYPE.TABLE)
         self.assertIsInstance(data.data_frame, DataFrame)
         expected_columns = ["id", "name"]
@@ -121,8 +126,7 @@ def test_native_query_no_results(self):
         mock_conn.cursor.assert_called_once_with(as_dict=True)
         mock_cursor.execute.assert_called_once_with(query_str)
 
-        assert isinstance(data, Response)
-        self.assertFalse(data.error_code)
+        assert isinstance(data, OkResponse)
         self.assertEqual(data.type, RESPONSE_TYPE.OK)
 
         mock_conn.commit.assert_called_once()
@@ -149,7 +153,7 @@ def test_native_query_error(self):
         mock_conn.cursor.assert_called_once_with(as_dict=True)
         mock_cursor.execute.assert_called_once_with(query_str)
 
-        assert isinstance(data, Response)
+        assert isinstance(data, ErrorResponse)
         self.assertEqual(data.type, RESPONSE_TYPE.ERROR)
         self.assertEqual(data.error_message, str(error))
 
@@ -166,7 +170,7 @@ def test_query_method(self):
         try:
             self.handler.renderer = renderer_mock
             self.handler.native_query = MagicMock()
-            self.handler.native_query.return_value = Response(RESPONSE_TYPE.OK)
+            self.handler.native_query.return_value = OkResponse()
 
             mock_ast = MagicMock()
             result = self.handler.query(mock_ast)
@@ -180,7 +184,7 @@ def test_get_tables(self):
         """
         Tests that get_tables calls native_query with the correct SQL
         """
-        expected_response = Response(RESPONSE_TYPE.OK)
+        expected_response = OkResponse()
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         response = self.handler.get_tables()
@@ -199,9 +203,7 @@ def test_get_columns(self):
         """
         Tests that get_columns calls native_query with the correct SQL
         """
-        expected_response = Response(
-            RESPONSE_TYPE.TABLE, data_frame=DataFrame([], columns=list(INF_SCHEMA_COLUMNS_NAMES_SET))
-        )
+        expected_response = TableResponse(data=DataFrame([], columns=list(INF_SCHEMA_COLUMNS_NAMES_SET)))
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         table_name = "test_table"
@@ -259,7 +261,7 @@ def test_meta_get_tables_returns_response(self):
                 },
             ]
         )
-        expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=df)
+        expected_response = TableResponse(data=df)
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         # without filter
@@ -271,7 +273,7 @@ def test_meta_get_tables_returns_response(self):
         self.handler.native_query.reset_mock()
         tables = ["customers", "orders"]
         filtered_df = df[df["table_name"].isin(tables)].reset_index(drop=True)
-        filtered_response = Response(RESPONSE_TYPE.TABLE, data_frame=filtered_df)
+        filtered_response = TableResponse(data=filtered_df)
         self.handler.native_query = MagicMock(return_value=filtered_response)
         response = self.handler.meta_get_tables(table_names=tables)
         self.handler.native_query.assert_called_once()
@@ -307,7 +309,7 @@ def test_meta_get_columns_returns_response(self):
                 },
             ]
         )
-        expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=df)
+        expected_response = TableResponse(data=df)
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         # without filter
@@ -319,7 +321,7 @@ def test_meta_get_columns_returns_response(self):
         self.handler.native_query.reset_mock()
         tables = ["customers"]
         filtered_df = df[df["table_name"].isin(tables)].reset_index(drop=True)
-        filtered_response = Response(RESPONSE_TYPE.TABLE, data_frame=filtered_df)
+        filtered_response = TableResponse(data=filtered_df)
         self.handler.native_query = MagicMock(return_value=filtered_response)
         response = self.handler.meta_get_columns(table_names=tables)
         self.handler.native_query.assert_called_once()
@@ -351,7 +353,7 @@ def test_meta_get_column_statistics_returns_response(self):
                 },
             ]
         )
-        expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=df)
+        expected_response = TableResponse(data=df)
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         # without filter
@@ -363,7 +365,7 @@ def test_meta_get_column_statistics_returns_response(self):
         self.handler.native_query.reset_mock()
         tables = ["customers"]
         filtered_df = df[df["TABLE_NAME"].isin(tables)].reset_index(drop=True)
-        filtered_response = Response(RESPONSE_TYPE.TABLE, data_frame=filtered_df)
+        filtered_response = TableResponse(data=filtered_df)
         self.handler.native_query = MagicMock(return_value=filtered_response)
         response = self.handler.meta_get_column_statistics(table_names=tables)
         self.handler.native_query.assert_called_once()
@@ -382,7 +384,7 @@ def test_meta_get_primary_keys_returns_response(self):
                 {"table_name": "orders", "column_name": "id", "ordinal_position": 1, "constraint_name": "pk_orders"},
             ]
         )
-        expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=df)
+        expected_response = TableResponse(data=df)
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         # without filter
@@ -394,7 +396,7 @@ def test_meta_get_primary_keys_returns_response(self):
         self.handler.native_query.reset_mock()
         tables = ["customers"]
         filtered_df = df[df["table_name"].isin(tables)].reset_index(drop=True)
-        filtered_response = Response(RESPONSE_TYPE.TABLE, data_frame=filtered_df)
+        filtered_response = TableResponse(data=filtered_df)
         self.handler.native_query = MagicMock(return_value=filtered_response)
         response = self.handler.meta_get_primary_keys(table_names=tables)
         self.handler.native_query.assert_called_once()
@@ -420,7 +422,7 @@ def test_meta_get_foreign_keys_returns_response(self):
                 },
             ]
         )
-        expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=df)
+        expected_response = TableResponse(data=df)
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         # without filter
@@ -432,7 +434,7 @@ def test_meta_get_foreign_keys_returns_response(self):
         self.handler.native_query.reset_mock()
         tables = ["orders"]
         filtered_df = df[df["child_table_name"].isin(tables)].reset_index(drop=True)
-        filtered_response = Response(RESPONSE_TYPE.TABLE, data_frame=filtered_df)
+        filtered_response = TableResponse(data=filtered_df)
         self.handler.native_query = MagicMock(return_value=filtered_response)
         response = self.handler.meta_get_foreign_keys(table_names=tables)
         self.handler.native_query.assert_called_once()
@@ -521,7 +523,7 @@ def test_meta_methods_result_shape_and_exceptions(self):
         for name, df_factory, method in methods:
             with self.subTest(method=name, case="no_filter"):
                 df = df_factory()
-                expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=df)
+                expected_response = TableResponse(data=df)
                 self.handler.native_query = MagicMock(return_value=expected_response)
                 res = method()
                 self.handler.native_query.assert_called_once()
@@ -533,7 +535,7 @@ def test_meta_methods_result_shape_and_exceptions(self):
 
             with self.subTest(method=name, case="with_filter"):
                 df = df_factory()
-                expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=df)
+                expected_response = TableResponse(data=df)
                 self.handler.native_query = MagicMock(return_value=expected_response)
                 res = (
                     method(table_names=["A", "B"])
@@ -639,6 +641,13 @@ def test_check_connection(self):
         self.assertFalse(response.success)
         self.assertEqual(response.error_message, "Connection error")
 
+        self.handler.connect.side_effect = ValueError("Invalid connection args")
+
+        response = self.handler.check_connection()
+
+        self.assertFalse(response.success)
+        self.assertEqual(response.error_message, "Invalid connection args")
+
     def test_types_casting(self):
         """Test that types are casted correctly"""
         query_str = "SELECT * FROM test_table"
@@ -726,7 +735,7 @@ def test_types_casting(self):
             ("n_real", 3, None, None, None, None, None),
         ]
 
-        response: Response = self.handler.native_query(query_str)
+        response: TableResponse = self.handler.native_query(query_str)
         excepted_mysql_types = [
             MYSQL_DATA_TYPE.TINYINT,
             MYSQL_DATA_TYPE.INT,
@@ -741,7 +750,7 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.FLOAT,
             MYSQL_DATA_TYPE.FLOAT,
         ]
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        self.assertEqual([col.type for col in response.columns], excepted_mysql_types)
         for columns_name, input_value in input_row.items():
             result_value = response.data_frame[columns_name][0]
             self.assertEqual(result_value, input_value)
@@ -818,7 +827,7 @@ def test_types_casting(self):
             ("t_uniqueidentifier", 2, None, None, None, None, None),
         ]
 
-        response: Response = self.handler.native_query(query_str)
+        response: TableResponse = self.handler.native_query(query_str)
         excepted_mysql_types = [
             MYSQL_DATA_TYPE.TEXT,
             MYSQL_DATA_TYPE.TEXT,
@@ -832,7 +841,7 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.TEXT,
             MYSQL_DATA_TYPE.BINARY,
         ]
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        self.assertEqual([col.type for col in response.columns], excepted_mysql_types)
         for columns_name, input_value in input_row.items():
             result_value = response.data_frame[columns_name][0]
             self.assertEqual(result_value, input_value)
@@ -901,7 +910,7 @@ def test_types_casting(self):
             ("d_datetimeoffset_p", 2, None, None, None, None, None),
         ]
 
-        response: Response = self.handler.native_query(query_str)
+        response: TableResponse = self.handler.native_query(query_str)
         excepted_mysql_types = [
             # DATE and TIME is not possible to infer, so they are BINARY
             MYSQL_DATA_TYPE.BINARY,
@@ -914,7 +923,7 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.DATETIME,
             MYSQL_DATA_TYPE.DATETIME,
         ]
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        self.assertEqual([col.type for col in response.columns], excepted_mysql_types)
         for columns_name, input_value in input_row.items():
             result_value = response.data_frame[columns_name][0]
             if columns_name == "d_datetimeoffset_p":
@@ -1099,7 +1108,7 @@ def __getitem__(self, idx):
             mock_conn.cursor.assert_called_once_with()
             mock_cursor.execute.assert_called_once_with(query_str)
 
-            self.assertIsInstance(response, Response)
+            self.assertIsInstance(response, TableResponse)
             self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
             self.assertIsInstance(response.data_frame, DataFrame)
             self.assertEqual(list(response.data_frame.columns), ["id", "name"])
@@ -1168,10 +1177,10 @@ def __getitem__(self, idx):
 
             response = handler.native_query("SELECT * FROM test")
 
-            self.assertIsInstance(response, Response)
+            self.assertIsInstance(response, TableResponse)
             self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
-            self.assertIsNotNone(response.mysql_types)
-            self.assertTrue(len(response.mysql_types) > 0)
+            self.assertIsNotNone(response.columns)
+            self.assertTrue(len(response.columns) > 0)
         finally:
             if "pyodbc" in sys.modules:
                 del sys.modules["pyodbc"]
diff --git a/tests/unit/handlers/test_mysql.py b/tests/unit/handlers/test_mysql.py
index bbb3ab93e56..a506e0ba844 100644
--- a/tests/unit/handlers/test_mysql.py
+++ b/tests/unit/handlers/test_mysql.py
@@ -12,7 +12,13 @@
 
 from base_handler_test import BaseDatabaseHandlerTest, MockCursorContextManager
 from mindsdb.integrations.handlers.mysql_handler.mysql_handler import MySQLHandler
-from mindsdb.integrations.libs.response import HandlerResponse as Response, INF_SCHEMA_COLUMNS_NAMES_SET, RESPONSE_TYPE
+from mindsdb.integrations.libs.response import (
+    OkResponse,
+    TableResponse,
+    DataHandlerResponse as Response,
+    INF_SCHEMA_COLUMNS_NAMES_SET,
+    RESPONSE_TYPE,
+)
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 
@@ -67,7 +73,8 @@ def get_columns_query(self):
             from
                 information_schema.columns
             where
-                table_name = '{self.mock_table}';
+                table_name = '{self.mock_table}'
+                and table_schema = DATABASE();
         """
 
     def create_handler(self):
@@ -89,13 +96,12 @@ def test_native_query(self):
         query_str = f"SELECT * FROM {self.mock_table}"
         data = self.handler.native_query(query_str)
 
-        self.assertIsInstance(data, Response)
-        self.assertFalse(data.error_code)
+        self.assertIsInstance(data, TableResponse)
 
     def test_native_query_with_results(self):
         """
         Tests the `native_query` method to ensure it executes a SQL query and handles the case
-        where the query returns a result set
+        where the query returns a result set, streaming data via fetchmany
         """
         mock_conn = MagicMock()
         mock_cursor = MagicMock()
@@ -106,7 +112,11 @@ def test_native_query_with_results(self):
         mock_conn.cursor = MagicMock(return_value=mock_cursor)
         mock_conn.is_connected = MagicMock(return_value=True)
 
-        mock_cursor.fetchall.return_value = [{"id": 1, "name": "test1"}, {"id": 2, "name": "test2"}]
+        # fetchmany returns tuples (non-dictionary cursor), then empty list to signal end
+        mock_cursor.fetchmany.side_effect = [
+            [(1, "test1"), (2, "test2")],
+            [],
+        ]
 
         # MySQL cursor provides column info via description attribute
         mock_cursor.description = [
@@ -119,12 +129,10 @@ def test_native_query_with_results(self):
         query_str = "SELECT * FROM test_table"
         data = self.handler.native_query(query_str)
 
-        mock_conn.cursor.assert_called_once_with(dictionary=True, buffered=True)
+        mock_conn.cursor.assert_called_once_with(buffered=False)
         mock_cursor.execute.assert_called_once_with(query_str)
 
-        assert isinstance(data, Response)
-        self.assertFalse(data.error_code)
-        self.assertEqual(data.type, RESPONSE_TYPE.TABLE)
+        assert isinstance(data, TableResponse)
         self.assertIsInstance(data.data_frame, DataFrame)
 
         expected_columns = ["id", "name"]
@@ -150,12 +158,10 @@ def test_native_query_no_results(self):
         query_str = "INSERT INTO test_table VALUES (1, 'test')"
         data = self.handler.native_query(query_str)
 
-        mock_conn.cursor.assert_called_once_with(dictionary=True, buffered=True)
+        mock_conn.cursor.assert_called_once_with(buffered=False)
         mock_cursor.execute.assert_called_once_with(query_str)
 
-        assert isinstance(data, Response)
-        self.assertFalse(data.error_code)
-        self.assertEqual(data.type, RESPONSE_TYPE.OK)
+        assert isinstance(data, OkResponse)
         self.assertEqual(data.affected_rows, 1)
 
     def test_native_query_error(self):
@@ -178,7 +184,7 @@ def test_native_query_error(self):
         query_str = "INVALID SQL"
         data = self.handler.native_query(query_str)
 
-        mock_conn.cursor.assert_called_once_with(dictionary=True, buffered=True)
+        mock_conn.cursor.assert_called_once_with(buffered=False)
         mock_cursor.execute.assert_called_once_with(query_str)
 
         assert isinstance(data, Response)
@@ -377,7 +383,7 @@ def test_query_method(self):
             mock_renderer_class.return_value = mock_renderer
 
             self.handler.native_query = MagicMock()
-            self.handler.native_query.return_value = Response(RESPONSE_TYPE.OK)
+            self.handler.native_query.return_value = OkResponse()
 
             mock_ast = MagicMock()
 
@@ -406,7 +412,7 @@ def test_get_tables(self):
         """
         Tests that get_tables calls native_query with the correct SQL
         """
-        expected_response = Response(RESPONSE_TYPE.OK)
+        expected_response = OkResponse()
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         response = self.handler.get_tables()
@@ -425,9 +431,7 @@ def test_get_columns(self):
         """
         Tests that get_columns calls native_query with the correct SQL
         """
-        expected_response = Response(
-            RESPONSE_TYPE.TABLE, data_frame=DataFrame([], columns=list(INF_SCHEMA_COLUMNS_NAMES_SET))
-        )
+        expected_response = TableResponse(data=DataFrame([], columns=list(INF_SCHEMA_COLUMNS_NAMES_SET)))
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         table_name = "test_table"
@@ -454,7 +458,8 @@ def test_get_columns(self):
             from
                 information_schema.columns
             where
-                table_name = '{table_name}';
+                table_name = '{table_name}'
+                and table_schema = DATABASE();
         """
         self.assertEqual(call_args, expected_sql)
         self.assertEqual(response, expected_response)
@@ -473,19 +478,19 @@ def test_types_casting(self):
         mock_conn.is_connected = MagicMock(return_value=True)
 
         # region test TEXT/BLOB types and sub-types
-        input_row = {
-            "t_varchar": "v_varchar",
-            "t_tinytext": "v_tinytext",
-            "t_text": "v_text",
-            "t_mediumtext": "v_mediumtext",
-            "t_longtext": "v_longtext",
-            "t_tinyblon": "v_tinyblon",
-            "t_blob": "v_blob",
-            "t_mediumblob": "v_mediumblob",
-            "t_longblob": "v_longblob",
-            "t_json": '{"key": "value"}',
-        }
-        mock_cursor.fetchall.return_value = [input_row]
+        input_row = OrderedDict(
+            t_varchar="v_varchar",
+            t_tinytext="v_tinytext",
+            t_text="v_text",
+            t_mediumtext="v_mediumtext",
+            t_longtext="v_longtext",
+            t_tinyblon="v_tinyblon",
+            t_blob="v_blob",
+            t_mediumblob="v_mediumblob",
+            t_longblob="v_longblob",
+            t_json='{"key": "value"}',
+        )
+        mock_cursor.fetchall.return_value = [list(input_row.values())]
 
         mock_cursor.description = [
             ("t_varchar", 253, None, None, None, None, 1, 0, 45),
@@ -500,7 +505,7 @@ def test_types_casting(self):
             ("t_json", 245, None, None, None, None, 1, 144, 63),
         ]
 
-        response: Response = self.handler.native_query(query_str)
+        response: Response = self.handler.native_query(query_str, stream=False)
         excepted_mysql_types = [
             MYSQL_DATA_TYPE.VARBINARY,
             MYSQL_DATA_TYPE.TEXT,
@@ -513,7 +518,8 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.BLOB,
             MYSQL_DATA_TYPE.JSON,
         ]
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        for column, mysql_type in zip(response.columns, excepted_mysql_types):
+            self.assertEqual(column.type, mysql_type)
         for key, input_value in input_row.items():
             result_value = response.data_frame[key][0]
             self.assertEqual(type(result_value), type(input_value))
@@ -521,17 +527,18 @@ def test_types_casting(self):
         # endregion
 
         # region test TINYINT/BOOL/BOOLEAN types
-        input_row = {"t_tinyint": 1, "t_bool": 1, "t_boolean": 1}
-        mock_cursor.fetchall.return_value = [input_row]
+        input_row = OrderedDict(t_tinyint=1, t_bool=1, t_boolean=1)
+        mock_cursor.fetchall.return_value = [list(input_row.values())]
 
         mock_cursor.description = [
             ("t_tinyint", 1, None, None, None, None, 1, 0, 63),
             ("t_bool", 1, None, None, None, None, 1, 0, 63),
             ("t_boolean", 1, None, None, None, None, 1, 0, 63),
         ]
-        response: Response = self.handler.native_query(query_str)
+        response: Response = self.handler.native_query(query_str, stream=False)
         excepted_mysql_types = [MYSQL_DATA_TYPE.TINYINT, MYSQL_DATA_TYPE.TINYINT, MYSQL_DATA_TYPE.TINYINT]
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        for column, mysql_type in zip(response.columns, excepted_mysql_types):
+            self.assertEqual(column.type, mysql_type)
         for key, input_value in input_row.items():
             result_value = response.data_frame[key][0]
             # without None values in result columns types will be one of pandas types
@@ -540,19 +547,19 @@ def test_types_casting(self):
         # endregion
 
         # region test numeric types
-        input_row = {
-            "t_tinyint": 1,
-            "t_bool": 0,
-            "t_smallint": 2,
-            "t_year": 2025,
-            "t_mediumint": 3,
-            "t_int": 4,
-            "t_bigint": 5,
-            "t_float": 1.1,
-            "t_double": 2.2,
-            "t_decimal": Decimal("3.3"),
-        }
-        mock_cursor.fetchall.return_value = [input_row]
+        input_row = OrderedDict(
+            t_tinyint=1,
+            t_bool=0,
+            t_smallint=2,
+            t_year=2025,
+            t_mediumint=3,
+            t_int=4,
+            t_bigint=5,
+            t_float=1.1,
+            t_double=2.2,
+            t_decimal=Decimal("3.3"),
+        )
+        mock_cursor.fetchall.return_value = [list(input_row.values())]
         mock_cursor.description = [
             ("t_tinyint", 1, None, None, None, None, 1, 0, 63),
             ("t_bool", 1, None, None, None, None, 1, 0, 63),
@@ -565,7 +572,7 @@ def test_types_casting(self):
             ("t_double", 5, None, None, None, None, 1, 0, 63),
             ("t_decimal", 246, None, None, None, None, 1, 0, 63),
         ]
-        response: Response = self.handler.native_query(query_str)
+        response: Response = self.handler.native_query(query_str, stream=False)
         excepted_mysql_types = [
             MYSQL_DATA_TYPE.TINYINT,
             MYSQL_DATA_TYPE.TINYINT,
@@ -579,21 +586,22 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.DECIMAL,
         ]
 
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        for column, mysql_type in zip(response.columns, excepted_mysql_types):
+            self.assertEqual(column.type, mysql_type)
         for key, input_value in input_row.items():
             result_value = response.data_frame[key][0]
             self.assertEqual(result_value, input_value)
         # endregion
 
         # test date/time types
-        input_row = {
-            "t_date": datetime.date(2025, 4, 16),
-            "t_time": datetime.timedelta(seconds=45600),
-            "t_year": 2025,
-            "t_datetime": datetime.datetime(2025, 4, 16, 12, 30, 15),
-            "t_timestamp": datetime.datetime(2025, 4, 16, 12, 30, 15),
-        }
-        mock_cursor.fetchall.return_value = [input_row]
+        input_row = OrderedDict(
+            t_date=datetime.date(2025, 4, 16),
+            t_time=datetime.timedelta(seconds=45600),
+            t_year=2025,
+            t_datetime=datetime.datetime(2025, 4, 16, 12, 30, 15),
+            t_timestamp=datetime.datetime(2025, 4, 16, 12, 30, 15),
+        )
+        mock_cursor.fetchall.return_value = [list(input_row.values())]
 
         mock_cursor.description = [
             ("t_date", 10, None, None, None, None, 1, 128, 63),
@@ -603,7 +611,7 @@ def test_types_casting(self):
             ("t_timestamp", 7, None, None, None, None, 1, 128, 63),
         ]
 
-        response: Response = self.handler.native_query(query_str)
+        response: Response = self.handler.native_query(query_str, stream=False)
         excepted_mysql_types = [
             MYSQL_DATA_TYPE.DATE,
             MYSQL_DATA_TYPE.TIME,
@@ -611,7 +619,8 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.DATETIME,
             MYSQL_DATA_TYPE.TIMESTAMP,
         ]
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        for column, mysql_type in zip(response.columns, excepted_mysql_types):
+            self.assertEqual(column.type, mysql_type)
         for key, input_value in input_row.items():
             result_value = response.data_frame[key][0]
             self.assertEqual(result_value, input_value)
@@ -619,14 +628,14 @@ def test_types_casting(self):
 
         # region test casting of nullable types
         bigint_val = 9223372036854775807
-        input_rows = [{"t_bigint": bigint_val, "t_boolean": 1}, {"t_bigint": None, "t_boolean": None}]
-        mock_cursor.fetchall.return_value = input_rows
+        input_rows = [OrderedDict(t_bigint=bigint_val, t_boolean=1), OrderedDict(t_bigint=None, t_boolean=None)]
+        mock_cursor.fetchall.return_value = [list(row.values()) for row in input_rows]
         description = [
             ("t_bigint", 8, None, None, None, None, 1, 0, 63),
             ("t_boolean", 1, None, None, None, None, 1, 0, 63),
         ]
         mock_cursor.description = description
-        response: Response = self.handler.native_query(query_str)
+        response: Response = self.handler.native_query(query_str, stream=False)
         self.assertEqual(response.data_frame.dtypes.iloc[0], "Int64")
         self.assertEqual(response.data_frame.dtypes.iloc[1], "Int64")
         self.assertEqual(response.data_frame.iloc[0, 0], bigint_val)
@@ -636,16 +645,17 @@ def test_types_casting(self):
         # endregion
 
         # region test vector type
-        input_row = {
-            "t_vector": array("f", [1.1, 2.2, 3.3]),
-        }
-        mock_cursor.fetchall.return_value = [input_row]
+        input_row = OrderedDict(
+            t_vector=array("f", [1.1, 2.2, 3.3]),
+        )
+        mock_cursor.fetchall.return_value = [list(input_row.values())]
 
         mock_cursor.description = [("t_vector", 242, None, None, None, None, 1, 144, 63)]
 
-        response: Response = self.handler.native_query(query_str)
+        response: Response = self.handler.native_query(query_str, stream=False)
         excepted_mysql_types = [MYSQL_DATA_TYPE.VECTOR]
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        for column, mysql_type in zip(response.columns, excepted_mysql_types):
+            self.assertEqual(column.type, mysql_type)
         self.assertEqual(input_row["t_vector"], response.data_frame["t_vector"][0])
         # endregion
 
@@ -661,7 +671,7 @@ def _test_meta_method_with_filter(self, method, sample_data, filter_column, filt
         """
         # Test without filter
         df = DataFrame(sample_data)
-        expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=df)
+        expected_response = TableResponse(data=df)
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         response = method()
@@ -671,7 +681,7 @@ def _test_meta_method_with_filter(self, method, sample_data, filter_column, filt
         # Test with filter
         self.handler.native_query.reset_mock()
         filtered_df = df[df[filter_column].isin(filter_values)].reset_index(drop=True)
-        filtered_response = Response(RESPONSE_TYPE.TABLE, data_frame=filtered_df)
+        filtered_response = TableResponse(data=filtered_df)
         self.handler.native_query = MagicMock(return_value=filtered_response)
 
         response = method(table_names=filter_values)
diff --git a/tests/unit/handlers/test_openbb_tables.py b/tests/unit/handlers/test_openbb_tables.py
new file mode 100644
index 00000000000..4817c12501c
--- /dev/null
+++ b/tests/unit/handlers/test_openbb_tables.py
@@ -0,0 +1,96 @@
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import pandas as pd
+import pytest
+
+from mindsdb.integrations.handlers.openbb_handler.openbb_tables import OpenBBtable
+
+
+class _DummyOpenBBResponse:
+    def __init__(self, payload):
+        self.payload = payload
+
+    def to_df(self):
+        return pd.DataFrame([self.payload])
+
+
+class _DummyPrice:
+    def historical(self, **kwargs):
+        return _DummyOpenBBResponse(kwargs)
+
+
+class _DummyEquity:
+    def __init__(self):
+        self.price = _DummyPrice()
+
+
+class _DummyCoverage:
+    def __init__(self):
+        self.commands = {".equity.price.historical": {}}
+
+
+class _DummyObb:
+    def __init__(self):
+        self.equity = _DummyEquity()
+        self.coverage = _DummyCoverage()
+
+
+class _DummyHandler:
+    def __init__(self):
+        self.obb = _DummyObb()
+
+
+def test_openbb_command_resolution_returns_callable():
+    table = OpenBBtable(_DummyHandler())
+
+    function = table._resolve_openbb_command("obb.equity.price.historical")
+    result = function(symbol="AAPL").to_df()
+
+    assert result.iloc[0]["symbol"] == "AAPL"
+
+
+def test_openbb_select_treats_params_as_data():
+    table = OpenBBtable(_DummyHandler())
+    malicious_value = "__import__('os').system('echo hacked')"
+    query = SimpleNamespace(where=object())
+
+    with patch(
+        "mindsdb.integrations.handlers.openbb_handler.openbb_tables.extract_comparison_conditions",
+        return_value=[["=", "cmd", "obb.equity.price.historical"], ["=", "symbol", malicious_value]],
+    ):
+        result = table.select(query)
+
+    assert result.iloc[0]["symbol"] == malicious_value
+
+
+def test_openbb_command_resolution_rejects_private_segments():
+    table = OpenBBtable(_DummyHandler())
+
+    with pytest.raises(ValueError, match="Invalid OpenBB command segment"):
+        table._resolve_openbb_command("obb.__class__")
+
+
+def test_openbb_select_coerces_literal_string_params():
+    table = OpenBBtable(_DummyHandler())
+    query = SimpleNamespace(where=object())
+
+    with patch(
+        "mindsdb.integrations.handlers.openbb_handler.openbb_tables.extract_comparison_conditions",
+        return_value=[
+            ["=", "cmd", "obb.equity.price.historical"],
+            ["=", "limit", "123"],
+            ["=", "adjusted", "true"],
+            ["=", "symbol", "'AAPL'"],
+            ["=", "ids", "[1, 2]"],
+            ["=", "raw_symbol", "AAPL"],
+        ],
+    ):
+        result = table.select(query)
+
+    row = result.iloc[0]
+    assert row["limit"] == 123
+    assert bool(row["adjusted"]) is True
+    assert row["symbol"] == "AAPL"
+    assert row["ids"] == [1, 2]
+    assert row["raw_symbol"] == "AAPL"
diff --git a/tests/unit/handlers/test_oracle.py b/tests/unit/handlers/test_oracle.py
index cfd8dd7423f..fb18a57fcc6 100644
--- a/tests/unit/handlers/test_oracle.py
+++ b/tests/unit/handlers/test_oracle.py
@@ -18,9 +18,11 @@
 import pandas as pd
 from pandas import DataFrame
 
-from base_handler_test import BaseDatabaseHandlerTest
+from base_handler_test import BaseDatabaseHandlerTest, MockCursorContextManager
 from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response,
+    TableResponse,
+    OkResponse,
+    ErrorResponse,
     INF_SCHEMA_COLUMNS_NAMES_SET,
     RESPONSE_TYPE,
 )
@@ -165,9 +167,42 @@ def test_thick_mode_connection(self):
             handler.connect()
             mock_init.assert_called_once_with(lib_dir="/path/to/oracle/client/lib")
 
-    def test_native_query_with_results(self):
+    def test_native_query_with_results_streaming(self):
         """
-        Tests the `native_query` method for a SELECT statement returning results.
+        Tests the `native_query` method for a SELECT statement returning results at server side execution.
+        """
+        mock_conn = MagicMock()
+        mock_cursor = MockCursorContextManager()
+
+        self.handler.connect = MagicMock(return_value=mock_conn)
+        mock_conn.cursor = MagicMock(return_value=mock_cursor)
+
+        # Server-side execution uses fetchmany, not fetchall
+        mock_cursor.fetchmany = MagicMock(side_effect=[[(1, "test1"), (2, "test2")], []])
+        mock_cursor.description = [
+            ("ID", None, None, None, None, None, None),
+            ("NAME", None, None, None, None, None, None),
+        ]
+
+        query_str = "SELECT ID, NAME FROM test_table"
+        data = self.handler.native_query(query_str, stream=True)
+
+        mock_conn.cursor.assert_called_once()
+        mock_cursor.execute.assert_called_once_with(query_str)
+
+        # Verify the response
+        self.assertIsInstance(data, TableResponse)
+        self.assertEqual(data.type, RESPONSE_TYPE.TABLE)
+        self.assertIsNone(data._data)
+        data.fetchall()
+        self.assertIsInstance(data._data, DataFrame)
+        expected_columns = ["ID", "NAME"]
+        self.assertListEqual(list(data.data_frame.columns), expected_columns)
+        self.assertEqual(len(data.data_frame), 2)
+
+    def test_native_query_with_no_streaming(self):
+        """
+        Tests the `native_query` method for a SELECT statement returning results at client side execution.
         """
         mock_conn = MagicMock()
         mock_cursor = MagicMock()
@@ -177,22 +212,21 @@ def test_native_query_with_results(self):
         self.handler.connect = MagicMock(return_value=mock_conn)
         mock_conn.cursor = MagicMock(return_value=mock_cursor)
 
-        mock_cursor.fetchall.return_value = [(1, "test1"), (2, "test2")]
+        mock_cursor.fetchall = MagicMock(return_value=[(1, "test1"), (2, "test2")])
         mock_cursor.description = [
             ("ID", None, None, None, None, None, None),
             ("NAME", None, None, None, None, None, None),
         ]
 
         query_str = "SELECT ID, NAME FROM test_table"
-        data = self.handler.native_query(query_str)
+        data = self.handler.native_query(query_str, stream=False)
 
         mock_conn.cursor.assert_called_once()
         mock_cursor.execute.assert_called_once_with(query_str)
         mock_cursor.fetchall.assert_called_once()
         mock_conn.commit.assert_called_once()
 
-        self.assertIsInstance(data, Response)
-        self.assertFalse(data.error_code)
+        self.assertIsInstance(data, TableResponse)
         self.assertEqual(data.type, RESPONSE_TYPE.TABLE)
         self.assertIsInstance(data.data_frame, DataFrame)
         expected_columns = ["ID", "NAME"]
@@ -222,8 +256,7 @@ def test_native_query_no_results(self):
         mock_cursor.fetchall.assert_not_called()
         mock_conn.commit.assert_called_once()
 
-        self.assertIsInstance(data, Response)
-        self.assertFalse(data.error_code)
+        self.assertIsInstance(data, OkResponse)
         self.assertEqual(data.type, RESPONSE_TYPE.OK)
         self.assertEqual(data.affected_rows, 1)
 
@@ -252,7 +285,7 @@ def test_native_query_error(self):
         mock_conn.rollback.assert_called_once()
         mock_conn.commit.assert_not_called()
 
-        self.assertIsInstance(data, Response)
+        self.assertIsInstance(data, ErrorResponse)
         self.assertEqual(data.type, RESPONSE_TYPE.ERROR)
         self.assertEqual(data.error_message, error_msg)
 
@@ -265,7 +298,7 @@ def test_query_method(self):
             orig_renderer = self.handler.renderer
 
         self.handler.native_query = MagicMock()
-        expected_response = Response(RESPONSE_TYPE.TABLE)
+        expected_response = TableResponse()
         self.handler.native_query.return_value = expected_response
         mock_ast = MagicMock()
 
@@ -299,7 +332,7 @@ def test_get_tables(self):
             ],
             columns=["TABLE_SCHEMA", "TABLE_NAME", "TABLE_TYPE"],
         )
-        expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=expected_df)
+        expected_response = TableResponse(data=expected_df)
 
         self.handler.native_query = MagicMock(return_value=expected_response)
 
@@ -364,7 +397,7 @@ def test_get_tables_multiple_schemas(self):
             ],
             columns=["TABLE_SCHEMA", "TABLE_NAME", "TABLE_TYPE"],
         )
-        expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=expected_df)
+        expected_response = TableResponse(data=expected_df)
 
         self.handler.native_query = MagicMock(return_value=expected_response)
 
@@ -448,7 +481,7 @@ def test_get_columns(self):
         ]
         expected_df = DataFrame(expected_df_data, columns=query_columns)
 
-        expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=expected_df)
+        expected_response = TableResponse(data=expected_df)
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         table_name = "test_table"
@@ -573,7 +606,7 @@ def test_types_casting(self):
             ("N_BINARY_DOUBLE", oracledb.DB_TYPE_NUMBER, 127, None, None, None, True),
         ]
 
-        response: Response = self.handler.native_query(query_str)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
         excepted_mysql_types = [
             MYSQL_DATA_TYPE.FLOAT,
             MYSQL_DATA_TYPE.DECIMAL,
@@ -590,7 +623,7 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.FLOAT,
             MYSQL_DATA_TYPE.FLOAT,
         ]
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        self.assertEqual([col.type for col in response.columns], excepted_mysql_types)
         for i, input_value in enumerate(input_row):
             result_value = response.data_frame[response.data_frame.columns[i]][0]
             self.assertEqual(result_value, input_value)
@@ -612,9 +645,9 @@ def test_types_casting(self):
             ("T_BOOLEAN", oracledb.DB_TYPE_BOOLEAN, None, None, None, None, True),
             ("T_BOOL", oracledb.DB_TYPE_BOOLEAN, None, None, None, None, True),
         ]
-        response: Response = self.handler.native_query(query_str)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
         excepted_mysql_types = [MYSQL_DATA_TYPE.BOOLEAN, MYSQL_DATA_TYPE.BOOLEAN]
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        self.assertEqual([col.type for col in response.columns], excepted_mysql_types)
         for i, input_value in enumerate(input_row):
             result_value = response.data_frame[response.data_frame.columns[i]][0]
             self.assertEqual(result_value, input_value)
@@ -680,7 +713,7 @@ def test_types_casting(self):
             ("T_RAW", oracledb.DB_TYPE_RAW, 100, 100, None, None, True),
             ("T_BLOB", oracledb.DB_TYPE_LONG_RAW, None, None, None, None, True),
         ]
-        response: Response = self.handler.native_query(query_str)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
         excepted_mysql_types = [
             MYSQL_DATA_TYPE.TEXT,
             MYSQL_DATA_TYPE.TEXT,
@@ -692,7 +725,7 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.BINARY,
             MYSQL_DATA_TYPE.BINARY,
         ]
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        self.assertEqual([col.type for col in response.columns], excepted_mysql_types)
         for i, input_value in enumerate(input_row):
             result_value = response.data_frame[response.data_frame.columns[i]][0]
             self.assertEqual(result_value, input_value)
@@ -739,13 +772,13 @@ def test_types_casting(self):
             ("D_TIMESTAMP", oracledb.DB_TYPE_TIMESTAMP, 23, None, 0, 6, True),
             ("D_TIMESTAMP_P", oracledb.DB_TYPE_TIMESTAMP, 23, None, 0, 9, True),
         ]
-        response: Response = self.handler.native_query(query_str)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
         excepted_mysql_types = [
             MYSQL_DATA_TYPE.DATE,
             MYSQL_DATA_TYPE.TIMESTAMP,
             MYSQL_DATA_TYPE.TIMESTAMP,
         ]
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        self.assertEqual([col.type for col in response.columns], excepted_mysql_types)
         for i, input_value in enumerate(input_row):
             result_value = response.data_frame[response.data_frame.columns[i]][0]
             self.assertEqual(result_value, input_value)
@@ -767,7 +800,7 @@ def test_types_casting(self):
             ),  # set 17 just to force cast to Int64
             ("T_BOOLEAN", oracledb.DB_TYPE_BOOLEAN, None, None, None, None, True),
         ]
-        response: Response = self.handler.native_query(query_str)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
         self.assertEqual(response.data_frame.dtypes[0], "Int64")
         self.assertEqual(response.data_frame.dtypes[1], "boolean")
         self.assertEqual(response.data_frame.iloc[0, 0], bigint_val)
@@ -800,12 +833,13 @@ def test_types_casting(self):
             ("T_EMBEDDING", oracledb.DB_TYPE_VECTOR, None, None, None, None, True),
             ("T_JSON", oracledb.DB_TYPE_JSON, None, None, None, None, True),
         ]
-        response: Response = self.handler.native_query(query_str)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
         excepted_mysql_types = [MYSQL_DATA_TYPE.VECTOR, MYSQL_DATA_TYPE.JSON]
+        self.assertEqual([col.type for col in response.columns], excepted_mysql_types)
         for i, input_value in enumerate(input_row):
             result_value = response.data_frame[response.data_frame.columns[i]][0]
             self.assertEqual(result_value, input_value)
-        # endreion
+        # endregion
 
     def test_insert(self):
         """
@@ -813,9 +847,7 @@ def test_insert(self):
         using insertmany for batch inserts.
         """
         mock_conn = MagicMock()
-        mock_cursor = MagicMock()
-        mock_cursor.__enter__ = MagicMock(return_value=mock_cursor)
-        mock_cursor.__exit__ = MagicMock(return_value=None)
+        mock_cursor = MockCursorContextManager()
 
         self.handler.connect = MagicMock(return_value=mock_conn)
         mock_conn.cursor = MagicMock(return_value=mock_cursor)
@@ -837,9 +869,7 @@ def test_insert_error(self):
         Tests the insert method to ensure it correctly handles errors
         """
         mock_conn = MagicMock()
-        mock_cursor = MagicMock()
-        mock_cursor.__enter__ = MagicMock(return_value=mock_cursor)
-        mock_cursor.__exit__ = MagicMock(return_value=None)
+        mock_cursor = MockCursorContextManager()
 
         self.handler.connect = MagicMock(return_value=mock_conn)
         mock_conn.cursor = MagicMock(return_value=mock_cursor)
@@ -869,7 +899,7 @@ def test_meta_get_tables(self, table_names=None):
                 "row_count",
             ],
         )
-        mock_response = Response(RESPONSE_TYPE.TABLE, data_frame=expected_df)
+        mock_response = TableResponse(data=expected_df)
         self.handler.native_query = MagicMock(return_value=mock_response)
 
         response = self.handler.meta_get_tables(table_names=table_names)
@@ -900,7 +930,7 @@ def test_meta_get_columns(self, table_names=None):
             ],
         )
 
-        mock_response = Response(RESPONSE_TYPE.TABLE, data_frame=expected_df)
+        mock_response = TableResponse(data=expected_df)
         self.handler.native_query = MagicMock(return_value=mock_response)
 
         table_name = "TABLE1"
@@ -934,7 +964,7 @@ def test_meta_get_column_statistics(self, table_names=None):
             ],
         )
 
-        mock_response = Response(RESPONSE_TYPE.TABLE, data_frame=expected_df)
+        mock_response = TableResponse(data=expected_df)
         self.handler.native_query = MagicMock(return_value=mock_response)
         table_names = ["STATS_TABLE"]
         response = self.handler.meta_get_column_statistics(table_names=table_names)
@@ -975,7 +1005,7 @@ def test_meta_get_primary_keys(self):
             ],
         )
 
-        mock_response = Response(RESPONSE_TYPE.TABLE, data_frame=expected_df)
+        mock_response = TableResponse(data=expected_df)
         self.handler.native_query = MagicMock(return_value=mock_response)
 
         table_names = ["USERS", "ORDERS"]
@@ -1024,7 +1054,7 @@ def test_meta_get_foreign_keys(self, table_names=None):
             ],
         )
 
-        mock_response = Response(RESPONSE_TYPE.TABLE, data_frame=expected_df)
+        mock_response = TableResponse(data=expected_df)
         self.handler.native_query = MagicMock(return_value=mock_response)
 
         table_names = ["ORDERS", "ORDER_ITEMS"]
diff --git a/tests/unit/handlers/test_postgres.py b/tests/unit/handlers/test_postgres.py
index 8ad5be6d414..a0e3adc1335 100644
--- a/tests/unit/handlers/test_postgres.py
+++ b/tests/unit/handlers/test_postgres.py
@@ -17,7 +17,12 @@
 
 from base_handler_test import BaseDatabaseHandlerTest, MockCursorContextManager
 from mindsdb.integrations.handlers.postgres_handler.postgres_handler import PostgresHandler, _map_type
-from mindsdb.integrations.libs.response import HandlerResponse as Response, RESPONSE_TYPE
+from mindsdb.integrations.libs.response import (
+    RESPONSE_TYPE,
+    TableResponse,
+    OkResponse,
+    ErrorResponse,
+)
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 
@@ -96,35 +101,64 @@ def create_handler(self):
     def create_patcher(self):
         return patch("psycopg.connect")
 
-    def test_native_query_command_ok(self):
+    def test_native_query_command_ok_stream(self):
         """
         Tests the `native_query` method to ensure it executes a SQL query and handles the case
         where the query doesn't return a result set (ExecStatus.COMMAND_OK)
         """
         mock_conn = MagicMock()
-        # Use MockCursorContextManager for simplified mocking
-        mock_cursor = MockCursorContextManager()
+        mock_cursor_server = MockCursorContextManager()
+        mock_cursor_client = MockCursorContextManager()
 
         self.handler.connect = MagicMock(return_value=mock_conn)
-        mock_conn.cursor = MagicMock(return_value=mock_cursor)
+        mock_conn.cursor = MagicMock(side_effect=[mock_cursor_server, mock_cursor_client])
 
-        mock_cursor.execute.return_value = None
+        syntax_error = psycopg.errors.SyntaxError('syntax error at or near "insert"')
+        mock_cursor_server.execute.side_effect = syntax_error
+        mock_cursor_client.execute.return_value = None
 
         # Setup pgresult
         mock_pgresult = MagicMock()
         mock_pgresult.status = ExecStatus.COMMAND_OK
-        mock_cursor.pgresult = mock_pgresult
-        mock_cursor.rowcount = 1
+        mock_cursor_client.pgresult = mock_pgresult
+        mock_cursor_client.rowcount = 1
 
         query_str = "INSERT INTO table VALUES (1, 2, 3)"
-        data = self.handler.native_query(query_str)
-        mock_cursor.execute.assert_called_once_with(query_str)
-        assert isinstance(data, Response)
-        self.assertFalse(data.error_code)
-        self.assertEqual(data.type, RESPONSE_TYPE.OK)
+        data = self.handler.native_query(query_str, stream=True)
+        mock_cursor_server.execute.assert_called_once_with(query_str)
+        mock_cursor_client.execute.assert_called_once_with(query_str)
+        assert isinstance(data, OkResponse)
         self.assertEqual(data.affected_rows, 1)
 
-    def test_native_query_with_results(self):
+    def test_native_query_command_ok_no_stream(self):
+        """
+        Tests the `native_query` at client side execution
+        """
+        mock_conn = MagicMock()
+        # mock_cursor_server = MockCursorContextManager()
+        mock_cursor_client = MockCursorContextManager()
+
+        self.handler.connect = MagicMock(return_value=mock_conn)
+        mock_conn.cursor = MagicMock(side_effect=[mock_cursor_client])
+
+        # syntax_error = psycopg.errors.SyntaxError('syntax error at or near "insert"')
+        # mock_cursor_server.execute.side_effect = syntax_error
+        mock_cursor_client.execute.return_value = None
+
+        # Setup pgresult
+        mock_pgresult = MagicMock()
+        mock_pgresult.status = ExecStatus.COMMAND_OK
+        mock_cursor_client.pgresult = mock_pgresult
+        mock_cursor_client.rowcount = 1
+
+        query_str = "INSERT INTO table VALUES (1, 2, 3)"
+        data = self.handler.native_query(query_str, stream=False)
+        # mock_cursor_server.execute.assert_called_once_with(query_str)
+        mock_cursor_client.execute.assert_called_once_with(query_str)
+        assert isinstance(data, OkResponse)
+        self.assertEqual(data.affected_rows, 1)
+
+    def test_native_query_with_results_client_side(self):
         """
         Tests the `native_query` method to ensure it executes a SQL query and handles the case
         where the query returns a result set
@@ -135,7 +169,7 @@ def test_native_query_with_results(self):
         self.handler.connect = MagicMock(return_value=mock_conn)
         mock_conn.cursor = MagicMock(return_value=mock_cursor)
 
-        mock_cursor.fetchall = MagicMock(return_value=[[1, "name1"], [2, "name2"]])
+        mock_cursor.fetchall = MagicMock(side_effect=[[[1, "name1"], [2, "name2"]], []])
 
         # Create proper description objects with necessary type_code for _cast_dtypes
         mock_cursor.description = [
@@ -149,14 +183,51 @@ def test_native_query_with_results(self):
         mock_cursor.pgresult = mock_pgresult
 
         query_str = "SELECT * FROM table"
-        data = self.handler.native_query(query_str)
+        data = self.handler.native_query(query_str, stream=False)
         mock_cursor.execute.assert_called_once_with(query_str)
-        assert isinstance(data, Response)
-        self.assertFalse(data.error_code)
+        assert isinstance(data, TableResponse)
+        assert getattr(data, "error_code", None) is None
         self.assertEqual(data.type, RESPONSE_TYPE.TABLE)
         self.assertIsInstance(data.data_frame, DataFrame)
         self.assertEqual(list(data.data_frame.columns), ["id", "name"])
 
+    def test_native_query_with_results_stream(self):
+        """
+        Tests the `native_query` method to ensure it executes a SQL query and handles the case
+        where the query returns a result set at server side execution
+        """
+        mock_conn = MagicMock()
+        mock_cursor = MockCursorContextManager()
+
+        self.handler.connect = MagicMock(return_value=mock_conn)
+        mock_conn.cursor = MagicMock(return_value=mock_cursor)
+
+        # Server-side execution uses fetchmany, not fetchall
+        mock_cursor.fetchmany = MagicMock(side_effect=[[[1, "name1"], [2, "name2"]], []])
+
+        mock_cursor.description = [
+            ColumnDescription(name="id", type_code=regtype_to_oid["integer"]),  # int4 type code
+            ColumnDescription(name="name", type_code=regtype_to_oid["text"]),  # text type code
+        ]
+
+        query_str = "SELECT * FROM table"
+        data = self.handler.native_query(query_str, stream=True)
+        mock_cursor.execute.assert_called_once_with(query_str)
+
+        # Verify the response
+        assert isinstance(data, TableResponse)
+        assert getattr(data, "error_code", None) is None
+        self.assertEqual(data.type, RESPONSE_TYPE.TABLE)
+        self.assertIsNone(data._data)
+        data.fetchall()
+        self.assertIsInstance(data._data, DataFrame)
+        self.assertEqual(list(data.data_frame.columns), ["id", "name"])
+
+        # Verify DataFrame contains all expected rows
+        self.assertEqual(len(data.data_frame), 2)
+        self.assertEqual(data.data_frame["id"].tolist(), [1, 2])
+        self.assertEqual(data.data_frame["name"].tolist(), ["name1", "name2"])
+
     def test_native_query_with_params(self):
         """
         Tests the `native_query` method with parameters to ensure executemany is called correctly
@@ -175,8 +246,7 @@ def test_native_query_with_params(self):
         params = [(1, "a"), (2, "b")]
         data = self.handler.native_query(query_str, params=params)
         mock_cursor.executemany.assert_called_once_with(query_str, params)
-        assert isinstance(data, Response)
-        self.assertFalse(data.error_code)
+        assert isinstance(data, OkResponse)
 
     def test_native_query_error(self):
         """
@@ -198,8 +268,7 @@ def test_native_query_error(self):
 
         mock_cursor.execute.assert_called_once_with(query_str)
 
-        assert isinstance(data, Response)
-        self.assertEqual(data.type, RESPONSE_TYPE.ERROR)
+        assert isinstance(data, ErrorResponse)
 
         # The handler implementation sets error_code to 0, check error_message instead
         self.assertEqual(data.error_code, 0)
@@ -260,30 +329,7 @@ def test_query_method_uses_renderer_params(self):
 
         self.assertEqual(result, "ok")
         self.handler.renderer.get_exec_params.assert_called_once_with(query_node, with_failback=True)
-        self.handler.native_query.assert_called_once_with("SELECT 1", ["foo"])
-
-    def test_query_stream_yields_batches(self):
-        mock_conn = MagicMock()
-        mock_cursor = MockCursorContextManager()
-        mock_cursor.pgresult = MagicMock(status=ExecStatus.TUPLES_OK)
-        mock_cursor.fetchmany = MagicMock(side_effect=[[(1, "name")], []])
-        mock_cursor.description = [
-            ColumnDescription(name="id", type_code=regtype_to_oid["integer"]),
-            ColumnDescription(name="name", type_code=regtype_to_oid["text"]),
-        ]
-
-        self.handler.connect = MagicMock(return_value=mock_conn)
-        mock_conn.cursor = MagicMock(return_value=mock_cursor)
-        self.handler.renderer.get_exec_params = MagicMock(return_value=("SELECT * FROM table", None))
-        self.handler.disconnect = MagicMock()
-
-        batches = list(self.handler.query_stream(MagicMock(), fetch_size=1))
-
-        self.assertEqual(len(batches), 1)
-        self.assertListEqual(list(batches[0].columns), ["id", "name"])
-        mock_conn.commit.assert_called_once()
-        mock_conn.rollback.assert_called_once()
-        self.handler.disconnect.assert_called_once()
+        self.handler.native_query.assert_called_once_with("SELECT 1", ["foo"], stream=False)
 
     def test_insert_respects_existing_column_case(self):
         if getattr(self.handler, "name", None) != "postgres":
@@ -299,9 +345,8 @@ def test_insert_respects_existing_column_case(self):
         mock_conn.cursor = MagicMock(return_value=mock_cursor)
         self.handler.disconnect = MagicMock()
         self.handler.get_columns = MagicMock(
-            return_value=Response(
-                RESPONSE_TYPE.TABLE,
-                data_frame=pd.DataFrame({"COLUMN_NAME": ["Id", "Amount"]}),
+            return_value=TableResponse(
+                data=pd.DataFrame({"COLUMN_NAME": ["Id", "Amount"]}),
             )
         )
 
@@ -318,6 +363,15 @@ def test_insert_respects_existing_column_case(self):
         self.assertIn('"Id"', executed_copy)
         self.assertIn('"Amount"', executed_copy)
 
+    def test_meta_get_column_statistics_returns_non_table_response(self):
+        error_response = ErrorResponse(error_message="boom")
+        self.handler.native_query = MagicMock(return_value=error_response)
+
+        result = self.handler.meta_get_column_statistics()
+
+        self.assertIs(result, error_response)
+        self.handler.native_query.assert_called_once()
+
     def test_cast_dtypes(self):
         """
         Tests the _cast_dtypes method to ensure it correctly converts PostgreSQL types to pandas types
@@ -444,13 +498,13 @@ def test_insert(self):
         mock_pgresult.status = ExecStatus.TUPLES_OK
         mock_cursor.pgresult = mock_pgresult
         mock_cursor.rowcount = 1
-        mock_cursor.fetchall = MagicMock(
-            return_value=[
-                ["a", "int", 1, None, "YES", None, None, None, None, None, None, None],
-                ["b", "int", 2, None, "YES", None, None, None, None, None, None, None],
-                ["c", "int", 3, None, "YES", None, None, None, None, None, None, None],
-            ]
-        )
+
+        get_columns_result = [
+            ["id", "int", 1, None, "YES", None, None, None, None, None, None, None],
+            ["name", "text", 2, None, "YES", None, None, None, None, None, None, None],
+        ]
+        mock_cursor.fetchmany = MagicMock(side_effect=[get_columns_result, []])
+
         information_schema_description = [
             ColumnDescription(name="COLUMN_NAME", type_code=regtype_to_oid["text"]),
             ColumnDescription(name="DATA_TYPE", type_code=regtype_to_oid["text"]),
@@ -474,19 +528,6 @@ def test_insert(self):
         copy_obj.__enter__ = MagicMock(return_value=copy_obj)
         copy_obj.__exit__ = MagicMock(return_value=None)
 
-        # region add result for 'get_columns' call
-        mock_pgresult = MagicMock()
-        mock_pgresult.status = ExecStatus.TUPLES_OK
-        mock_cursor.pgresult = mock_pgresult
-        mock_cursor.fetchall = MagicMock(
-            return_value=[
-                ["id", "int", 1, None, "YES", None, None, None, None, None, None, None],
-                ["name", "text", 2, None, "YES", None, None, None, None, None, None, None],
-            ]
-        )
-        mock_cursor.description = information_schema_description
-        # endregino
-
         df = pd.DataFrame({"id": [1, 2, 3], "name": ["a", "b", "c"]})
 
         self.handler.insert("test_table", df)
@@ -643,9 +684,11 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.VARCHAR,
             MYSQL_DATA_TYPE.VARCHAR,
         ]
-        response: Response = self.handler.native_query(query_str)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
+
+        for column, mysql_type in zip(response.columns, excepted_mysql_types):
+            self.assertEqual(column.type, mysql_type)
 
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
         for i, input_value in enumerate(input_row):
             result_value = response.data_frame[description[i].name][0]
             self.assertEqual(type(result_value), type(input_value), f"type mismatch: {result_value} != {input_value}")
@@ -657,8 +700,9 @@ def test_types_casting(self):
         mock_cursor.fetchall.return_value = input_rows
         mock_cursor.description = [ColumnDescription(name="t_boolean", type_code=16)]
         excepted_mysql_types = [MYSQL_DATA_TYPE.BOOL]
-        response: Response = self.handler.native_query(query_str)
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
+        for column, mysql_type in zip(response.columns, excepted_mysql_types):
+            self.assertEqual(column.type, mysql_type)
         self.assertTrue(pd_types.is_bool_dtype(response.data_frame["t_boolean"][0]))
         self.assertTrue(bool(response.data_frame["t_boolean"][0]) is True)
         self.assertTrue(bool(response.data_frame["t_boolean"][1]) is False)
@@ -774,8 +818,9 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.FLOAT,  # n_float4
             MYSQL_DATA_TYPE.DOUBLE,  # n_float8
         ]
-        response: Response = self.handler.native_query(query_str)
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
+        for column, mysql_type in zip(response.columns, excepted_mysql_types):
+            self.assertEqual(column.type, mysql_type)
         for i, input_value in enumerate(input_row):
             result_value = response.data_frame[description[i].name][0]
             self.assertEqual(result_value, input_value, f"value mismatch: {result_value} != {input_value}")
@@ -850,8 +895,9 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.TIME,  # TIMETZ
         ]
 
-        response: Response = self.handler.native_query(query_str)
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
+        for column, mysql_type in zip(response.columns, excepted_mysql_types):
+            self.assertEqual(column.type, mysql_type)
         for i, input_value in enumerate(input_row):
             result_value = response.data_frame[description[i].name][0]
             self.assertEqual(result_value, input_value, f"value mismatch: {result_value} != {input_value}")
@@ -866,7 +912,7 @@ def test_types_casting(self):
             ColumnDescription(name="t_boolean", type_code=16),
         ]
         mock_cursor.description = description
-        response: Response = self.handler.native_query(query_str)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
         self.assertEqual(response.data_frame.dtypes[0], "Int64")
         self.assertEqual(response.data_frame.dtypes[1], "boolean")
         self.assertEqual(response.data_frame.iloc[0, 0], bigint_val)
@@ -921,8 +967,9 @@ def test_types_casting(self):
             MYSQL_DATA_TYPE.VECTOR,
         ]
 
-        response: Response = self.handler.native_query(query_str)
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        response: TableResponse = self.handler.native_query(query_str, stream=False)
+        for column, mysql_type in zip(response.columns, excepted_mysql_types):
+            self.assertEqual(column.type, mysql_type)
         for i, input_value in enumerate(input_row):
             result_value = response.data_frame[description[i].name][0]
             self.assertEqual(type(result_value), type(input_value), f"type mismatch: {result_value} != {input_value}")
@@ -933,7 +980,7 @@ def test_types_casting(self):
         # endregion
 
     def test_get_tables_all_flag(self):
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame()))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=pd.DataFrame()))
         self.handler.get_tables(all=True)
         query = self.handler.native_query.call_args[0][0]
         self.assertNotIn("current_schema()", query.split("table_schema")[-1])
@@ -955,19 +1002,19 @@ def test_get_columns_with_schema_name(self):
                 "COLLATION_NAME": [None],
             }
         )
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=df))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=df))
         self.handler.get_columns("customers", schema_name="analytics")
         query = self.handler.native_query.call_args[0][0]
         self.assertIn("table_schema = 'analytics'", query)
 
     def test_meta_get_tables_filters_by_list(self):
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame()))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=pd.DataFrame()))
         self.handler.meta_get_tables(table_names=["orders"])
         query = self.handler.native_query.call_args[0][0]
         self.assertIn("IN ('orders')", query)
 
     def test_meta_get_columns_filters_by_list(self):
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame()))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=pd.DataFrame()))
         self.handler.meta_get_columns(table_names=["orders"])
         query = self.handler.native_query.call_args[0][0]
         self.assertIn("IN ('orders')", query)
@@ -984,7 +1031,7 @@ def test_meta_get_column_statistics_transforms_histogram(self):
                 "histogram_bounds": ["{1,5,10}"],
             }
         )
-        response = Response(RESPONSE_TYPE.TABLE, data_frame=df)
+        response = TableResponse(data=df)
         self.handler.native_query = MagicMock(return_value=response)
 
         result = self.handler.meta_get_column_statistics(table_names=["orders"])
@@ -995,13 +1042,13 @@ def test_meta_get_column_statistics_transforms_histogram(self):
         self.assertEqual(result.data_frame.loc[0, "MOST_COMMON_VALUES"], ["A", "B"])
 
     def test_meta_get_primary_keys_with_filter(self):
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame()))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=pd.DataFrame()))
         self.handler.meta_get_primary_keys(table_names=["orders"])
         query = self.handler.native_query.call_args[0][0]
         self.assertIn("AND tc.table_name IN ('orders')", query)
 
     def test_meta_get_foreign_keys_with_filter(self):
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame()))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=pd.DataFrame()))
         self.handler.meta_get_foreign_keys(table_names=["orders"])
         query = self.handler.native_query.call_args[0][0]
         self.assertIn("AND tc.table_name IN ('orders')", query)
diff --git a/tests/unit/handlers/test_redshift.py b/tests/unit/handlers/test_redshift.py
index 8ee9a4f7e27..1d40b93fb4d 100644
--- a/tests/unit/handlers/test_redshift.py
+++ b/tests/unit/handlers/test_redshift.py
@@ -5,18 +5,21 @@
 import pandas as pd
 import psycopg
 
-from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response,
-    RESPONSE_TYPE
-)
+from mindsdb.integrations.libs.response import OkResponse, ErrorResponse, RESPONSE_TYPE
 from mindsdb.integrations.handlers.redshift_handler.redshift_handler import RedshiftHandler
 from test_postgres import TestPostgresHandler
 
 
 class TestRedshiftHandler(TestPostgresHandler):
-
     def create_handler(self):
-        return RedshiftHandler('redshift', connection_data=self.dummy_connection_data)
+        return RedshiftHandler("redshift", connection_data=self.dummy_connection_data)
+
+    def test_native_query(self):
+        """
+        This test is overridden to avoid issues with the generic MockCursorContextManager not being compatible with Postgres/Redshift cursor behavior.
+        More specific tests (test_native_query_with_results, test_native_query_command_ok, test_native_query_error) cover this functionality.
+        """
+        pass
 
     def test_insert(self):
         """
@@ -32,20 +35,17 @@ def test_insert(self):
 
         mock_cursor.executemany.return_value = None
 
-        df = pd.DataFrame({
-            'column1': [1, 2, 3, np.nan],
-            'column2': ['a', 'b', 'c', None]
-        })
+        df = pd.DataFrame({"column1": [1, 2, 3, np.nan], "column2": ["a", "b", "c", None]})
 
-        table_name = 'mock_table'
+        table_name = "mock_table"
         response = self.handler.insert(table_name, df)
 
-        columns = ', '.join([f'"{col}"' if ' ' in col else col for col in df.columns])
-        values = ', '.join(['%s' for _ in range(len(df.columns))])
-        expected_query = f'INSERT INTO {table_name} ({columns}) VALUES ({values})'
+        columns = ", ".join([f'"{col}"' if " " in col else col for col in df.columns])
+        values = ", ".join(["%s" for _ in range(len(df.columns))])
+        expected_query = f"INSERT INTO {table_name} ({columns}) VALUES ({values})"
 
         mock_cursor.executemany.assert_called_once_with(expected_query, df.replace({np.nan: None}).values.tolist())
-        assert isinstance(response, Response)
+        assert isinstance(response, OkResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.OK)
         mock_conn.commit.assert_called_once()
 
@@ -65,17 +65,14 @@ def test_insert_error(self):
         error = psycopg.Error(error_msg)
         mock_cursor.executemany.side_effect = error
 
-        df = pd.DataFrame({
-            'column1': [1, 2, 3, np.nan],
-            'column2': ['a', 'b', 'c', None]
-        })
+        df = pd.DataFrame({"column1": [1, 2, 3, np.nan], "column2": ["a", "b", "c", None]})
 
-        response = self.handler.insert('nonexistent_table', df)
+        response = self.handler.insert("nonexistent_table", df)
 
         mock_cursor.executemany.assert_called_once()
         mock_conn.rollback.assert_called_once()
 
-        assert isinstance(response, Response)
+        assert isinstance(response, ErrorResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.ERROR)
         self.assertEqual(response.error_message, error_msg)
 
@@ -91,21 +88,21 @@ def test_insert_with_empty_dataframe(self):
         self.handler.connect = MagicMock(return_value=mock_conn)
         mock_conn.cursor = MagicMock(return_value=mock_cursor)
 
-        df = pd.DataFrame(columns=['column1', 'column2'])
+        df = pd.DataFrame(columns=["column1", "column2"])
 
-        table_name = 'mock_table'
+        table_name = "mock_table"
         response = self.handler.insert(table_name, df)
 
-        columns = ', '.join([f'"{col}"' if ' ' in col else col for col in df.columns])
-        values = ', '.join(['%s' for _ in range(len(df.columns))])
-        expected_query = f'INSERT INTO {table_name} ({columns}) VALUES ({values})'
+        columns = ", ".join([f'"{col}"' if " " in col else col for col in df.columns])
+        values = ", ".join(["%s" for _ in range(len(df.columns))])
+        expected_query = f"INSERT INTO {table_name} ({columns}) VALUES ({values})"
 
         mock_cursor.executemany.assert_called_once()
         call_args, call_kwargs = mock_cursor.executemany.call_args
         self.assertEqual(call_args[0], expected_query)
         self.assertEqual(len(call_args[1]), 0)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, OkResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.OK)
 
         mock_conn.commit.assert_called_once()
@@ -123,25 +120,27 @@ def test_insert_with_special_column_names(self):
         self.handler.connect = MagicMock(return_value=mock_conn)
         mock_conn.cursor = MagicMock(return_value=mock_cursor)
 
-        df = pd.DataFrame({
-            'normal_column': [1, 2],
-            'column with spaces': ['a', 'b'],
-            'column-with-hyphens': [True, False],
-            'mixed@column#123': [3.14, 2.71]
-        })
+        df = pd.DataFrame(
+            {
+                "normal_column": [1, 2],
+                "column with spaces": ["a", "b"],
+                "column-with-hyphens": [True, False],
+                "mixed@column#123": [3.14, 2.71],
+            }
+        )
 
-        table_name = 'mock_table'
+        table_name = "mock_table"
         response = self.handler.insert(table_name, df)
 
         call_args = mock_cursor.executemany.call_args[0][0]
 
         for col in df.columns:
-            if ' ' in col:
+            if " " in col:
                 self.assertIn(f'"{col}"', call_args)
             else:
                 self.assertTrue(col in call_args or f'"{col}"' in call_args)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, OkResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.OK)
 
     def test_insert_disconnect_when_needed(self):
@@ -159,15 +158,15 @@ def test_insert_disconnect_when_needed(self):
         self.handler.disconnect = MagicMock()
         mock_conn.cursor = MagicMock(return_value=mock_cursor)
 
-        df = pd.DataFrame({'column1': [1, 2, 3]})
-        self.handler.insert('mock_table', df)
+        df = pd.DataFrame({"column1": [1, 2, 3]})
+        self.handler.insert("mock_table", df)
         self.handler.disconnect.assert_called_once()
         self.handler.connect.reset_mock()
         self.handler.disconnect.reset_mock()
         self.handler.is_connected = True
-        self.handler.insert('mock_table', df)
+        self.handler.insert("mock_table", df)
         self.handler.disconnect.assert_not_called()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()
diff --git a/tests/unit/handlers/test_s3.py b/tests/unit/handlers/test_s3.py
index 16f3e7e64b2..6911cef1cf7 100644
--- a/tests/unit/handlers/test_s3.py
+++ b/tests/unit/handlers/test_s3.py
@@ -11,32 +11,33 @@
 from base_handler_test import BaseHandlerTestSetup
 from mindsdb.integrations.handlers.s3_handler.s3_handler import S3Handler
 from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response,
+    OkResponse,
+    TableResponse,
+    DataHandlerResponse as Response,
     HandlerStatusResponse as StatusResponse,
-    RESPONSE_TYPE
+    RESPONSE_TYPE,
 )
 
 
 class TestS3Handler(BaseHandlerTestSetup, unittest.TestCase):
-
     @property
     def object_name(self):
-        return '`my-bucket/my-file.csv`'
+        return "`my-bucket/my-file.csv`"
 
     @property
     def dummy_connection_data(self):
         return OrderedDict(
-            aws_access_key_id='AQAXEQK89OX07YS34OP',
-            aws_secret_access_key='wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-            bucket='mindsdb-bucket',
-            region_name='us-east-2',
+            aws_access_key_id="AQAXEQK89OX07YS34OP",
+            aws_secret_access_key="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+            bucket="mindsdb-bucket",
+            region_name="us-east-2",
         )
 
     def create_handler(self):
-        return S3Handler('s3', connection_data=self.dummy_connection_data)
+        return S3Handler("s3", connection_data=self.dummy_connection_data)
 
     def create_patcher(self):
-        return patch('boto3.client')
+        return patch("boto3.client")
 
     def test_connect(self):
         """
@@ -51,7 +52,7 @@ def test_connect(self):
         self.assertTrue(self.handler.is_connected)
         self.mock_connect.assert_called_once()
 
-    @patch('boto3.client')
+    @patch("boto3.client")
     def test_check_connection_success(self, mock_boto3_client):
         """
         Test that the `check_connection` method returns a StatusResponse object and accurately reflects the connection status on a successful connection.
@@ -66,7 +67,7 @@ def test_check_connection_success(self, mock_boto3_client):
         assert isinstance(response, StatusResponse)
         self.assertFalse(response.error_message)
 
-    @patch('boto3.client')
+    @patch("boto3.client")
     def test_check_connection_failure_invalid_bucket_or_no_access(self, mock_boto3_client):
         """
         Test that the `check_connection` method returns a StatusResponse object and accurately reflects the connection status on failed connection due to invalid bucket or lack of access permissions.
@@ -76,12 +77,12 @@ def test_check_connection_failure_invalid_bucket_or_no_access(self, mock_boto3_c
         mock_boto3_client.return_value = mock_boto3_client_instance
         mock_boto3_client_instance.head_bucket.side_effect = ClientError(
             error_response={
-                'Error': {
-                    'Code': '404',
-                    'Message': 'Not Found',
+                "Error": {
+                    "Code": "404",
+                    "Message": "Not Found",
                 }
             },
-            operation_name='HeadBucket'
+            operation_name="HeadBucket",
         )
 
         response = self.handler.check_connection()
@@ -90,7 +91,7 @@ def test_check_connection_failure_invalid_bucket_or_no_access(self, mock_boto3_c
         assert isinstance(response, StatusResponse)
         self.assertTrue(response.error_message)
 
-    @patch('boto3.client')
+    @patch("boto3.client")
     def test_query_select(self, mock_boto3_client):
         """
         Tests the `query` method to ensure it executes a SELECT SQL query using a mock cursor and returns a Response object.
@@ -104,18 +105,11 @@ def test_query_select(self, mock_boto3_client):
         duckdb_connect = MagicMock()
         self.handler._connect_duckdb = duckdb_connect
         duckdb_execute = duckdb_connect().__enter__().execute
-        duckdb_execute().fetchdf.return_value = pd.DataFrame([], columns=['col_2'])
+        duckdb_execute().fetchdf.return_value = pd.DataFrame([], columns=["col_2"])
 
         # Craft the SELECT query and execute it.
-        object_name = 'my-bucket/my-file.csv'
-        select = ast.Select(
-            targets=[
-                Star()
-            ],
-            from_table=Identifier(
-                parts=[object_name]
-            )
-        )
+        object_name = "my-bucket/my-file.csv"
+        select = ast.Select(targets=[Star()], from_table=Identifier(parts=[object_name]))
 
         duckdb_execute.reset_mock()
         response = self.handler.query(select)
@@ -124,10 +118,9 @@ def test_query_select(self, mock_boto3_client):
             f"SELECT * FROM 's3://{self.dummy_connection_data['bucket']}/{object_name.replace('`', '')}'"
         )
 
-        assert isinstance(response, Response)
-        self.assertFalse(response.error_code)
+        assert isinstance(response, TableResponse)
 
-    @patch('boto3.client')
+    @patch("boto3.client")
     def test_query_insert(self, mock_boto3_client):
         """
         Tests the `query` method to ensure it executes a INSERT SQL query using a mock cursor and returns a Response object.
@@ -145,29 +138,25 @@ def test_query_insert(self, mock_boto3_client):
         duckdb_execute().fetchdf.return_value = None
 
         # Craft the INSERT query and execute it.
-        columns = ['col_1', 'col_2']
-        values = [('val_1', 'val_2')]
-        insert = ast.Insert(
-            table=Identifier(
-                parts=[self.object_name]
-            ),
-            columns=columns,
-            values=values
-        )
+        columns = ["col_1", "col_2"]
+        values = [("val_1", "val_2")]
+        insert = ast.Insert(table=Identifier(parts=[self.object_name]), columns=columns, values=values)
         duckdb_execute.reset_mock()
         response = self.handler.query(insert)
 
         sqls = [i[0][0] for i in duckdb_execute.call_args_list]
-        assert sqls[0] == f"CREATE TABLE tmp_table AS SELECT * FROM 's3://{self.dummy_connection_data['bucket']}/{self.object_name}'"
+        assert (
+            sqls[0]
+            == f"CREATE TABLE tmp_table AS SELECT * FROM 's3://{self.dummy_connection_data['bucket']}/{self.object_name}'"
+        )
 
         assert sqls[1] == "INSERT INTO tmp_table BY NAME SELECT * FROM df"
 
         assert sqls[2] == f"COPY tmp_table TO 's3://{self.dummy_connection_data['bucket']}/{self.object_name}'"
 
-        assert isinstance(response, Response)
-        self.assertFalse(response.error_code)
+        assert isinstance(response, OkResponse)
 
-    @patch('boto3.client')
+    @patch("boto3.client")
     def test_get_tables(self, mock_boto3_client):
         """
         Test that the `get_tables` method correctly calls the `list_objects_v2` method and returns a Response object with the supported objects (files).
@@ -176,12 +165,12 @@ def test_get_tables(self, mock_boto3_client):
         mock_boto3_client_instance = MagicMock()
         mock_boto3_client.return_value = mock_boto3_client_instance
         mock_boto3_client_instance.list_objects_v2.return_value = {
-            'Contents': [
-                {'Key': 'file1.csv'},
-                {'Key': 'file2.tsv'},
-                {'Key': 'file3.json'},
-                {'Key': 'file4.parquet'},
-                {'Key': 'file5.xlsx'},
+            "Contents": [
+                {"Key": "file1.csv"},
+                {"Key": "file2.tsv"},
+                {"Key": "file3.json"},
+                {"Key": "file4.parquet"},
+                {"Key": "file5.xlsx"},
             ]
         }
 
@@ -192,37 +181,32 @@ def test_get_tables(self, mock_boto3_client):
 
         df = response.data_frame
         self.assertEqual(len(df), 5)  # +1 table is 'files'
-        self.assertNotIn('file5.xlsx', df['table_name'].values)
+        self.assertNotIn("file5.xlsx", df["table_name"].values)
 
-    @patch('mindsdb.integrations.handlers.s3_handler.s3_handler.S3Handler.query')
+    @patch("mindsdb.integrations.handlers.s3_handler.s3_handler.S3Handler.query")
     def test_get_columns(self, mock_query):
         """
         Test that the `get_columns` method correctly constructs the SQL query and calls `native_query` with the correct query.
         """
-        mock_query.return_value = Response(
-            RESPONSE_TYPE.TABLE,
-            data_frame=pd.DataFrame(
+        mock_query.return_value = TableResponse(
+            data=pd.DataFrame(
                 data={
-                    'col_1': ['row_1', 'row_2', 'row_3'],
-                    'col_2': [1, 2, 3],
+                    "col_1": ["row_1", "row_2", "row_3"],
+                    "col_2": [1, 2, 3],
                 },
             )
         )
 
-        table_name = 'mock_table'
+        table_name = "mock_table"
         response = self.handler.get_columns(table_name)
 
-        expected_query = Select(
-            targets=[Star()],
-            from_table=Identifier(parts=[table_name]),
-            limit=Constant(1)
-        )
+        expected_query = Select(targets=[Star()], from_table=Identifier(parts=[table_name]), limit=Constant(1))
         self.handler.query.assert_called_once_with(expected_query)
 
         df = response.data_frame
-        self.assertEqual(df.columns.tolist(), ['column_name', 'data_type'])
-        self.assertEqual(df['data_type'].values.tolist(), ['string', 'int64'])
+        self.assertEqual(df.columns.tolist(), ["column_name", "data_type"])
+        self.assertEqual(df["data_type"].values.tolist(), ["string", "int64"])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()
diff --git a/tests/unit/handlers/test_salesforce.py b/tests/unit/handlers/test_salesforce.py
index 54253f3eef8..62be61a18f2 100644
--- a/tests/unit/handlers/test_salesforce.py
+++ b/tests/unit/handlers/test_salesforce.py
@@ -16,7 +16,7 @@
 from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator
 
 from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response,
+    TableResponse,
     HandlerStatusResponse as StatusResponse,
     RESPONSE_TYPE,
 )
@@ -157,7 +157,7 @@ def test_check_connection_failure(self):
 
     def test_get_tables(self):
         """
-        Test that the `get_tables` method returns a list of tables mapped from the Salesforce API.
+        Test that the `get_tables` method returns a TableResponse with a list of tables mapped from the Salesforce API.
         """
         mock_tables = ["Account", "Contact"]
         self.mock_connect.return_value = MagicMock(
@@ -168,7 +168,7 @@ def test_get_tables(self):
         self.handler.connect()
         response = self.handler.get_tables()
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -177,7 +177,7 @@ def test_get_tables(self):
 
     def test_get_columns(self):
         """
-        Test that the `get_columns` method returns a list of columns for a given table.
+        Test that the `get_columns` method returns a TableResponse with a list of columns for a given table.
         """
         mock_columns = ["Id", "Name", "Email"]
         mock_table = "Contact"
@@ -203,7 +203,7 @@ def test_get_columns(self):
         self.handler.connect()
         response = self.handler.get_columns(mock_table)
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
 
         df = response.data_frame
@@ -435,7 +435,7 @@ def test_meta_get_tables_filters_requested_tables(self):
 
         with patch(
             "mindsdb.integrations.handlers.salesforce_handler.salesforce_handler.MetaAPIHandler.meta_get_tables",
-            return_value=Response(RESPONSE_TYPE.TABLE, None),
+            return_value=TableResponse(),
         ) as mock_meta:
             response = self.handler.meta_get_tables(table_names=["contact"])
 
diff --git a/tests/unit/handlers/test_slack.py b/tests/unit/handlers/test_slack.py
index 59c64de18b0..62a9ada8bc8 100644
--- a/tests/unit/handlers/test_slack.py
+++ b/tests/unit/handlers/test_slack.py
@@ -12,7 +12,7 @@
 import pandas as pd
 
 from base_handler_test import BaseAPIChatHandlerTest, BaseAPIResourceTestSetup
-from mindsdb.integrations.libs.response import HandlerStatusResponse as StatusResponse, HandlerResponse as Response
+from mindsdb.integrations.libs.response import HandlerStatusResponse as StatusResponse, TableResponse
 from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator
 
 try:
@@ -431,7 +431,7 @@ def test_native_query(self):
         response = self.handler.native_query(query)
 
         self.mock_connect.return_value.conversations_info.assert_called_once_with(channel="C1234567890")
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         expected_df = pd.DataFrame([MOCK_RESPONSE_CONV_INFO_1["channel"]])
         pd.testing.assert_frame_equal(response.data_frame, expected_df)
 
@@ -451,7 +451,7 @@ def test_native_query_with_pagination(self):
         self.mock_connect.return_value.conversations_list.assert_any_call()
         self.mock_connect.return_value.conversations_list.assert_any_call(cursor="dGVhbTpDMDYxRkE1UEI=")
 
-        assert isinstance(response, Response)
+        assert isinstance(response, TableResponse)
         expected_df = pd.DataFrame(MOCK_RESPONSE_CONV_LIST_1["channels"] + MOCK_RESPONSE_CONV_LIST_2["channels"])
         pd.testing.assert_frame_equal(response.data_frame, expected_df)
 
diff --git a/tests/unit/handlers/test_snowflake.py b/tests/unit/handlers/test_snowflake.py
index e43aec5eac5..07c0c87b040 100644
--- a/tests/unit/handlers/test_snowflake.py
+++ b/tests/unit/handlers/test_snowflake.py
@@ -16,11 +16,16 @@
 import numpy as np
 import pandas as pd
 from pandas import DataFrame
-from types import SimpleNamespace
 
 
 from base_handler_test import BaseDatabaseHandlerTest
-from mindsdb.integrations.libs.response import HandlerResponse as Response, INF_SCHEMA_COLUMNS_NAMES_SET, RESPONSE_TYPE
+from mindsdb.integrations.libs.response import (
+    OkResponse,
+    TableResponse,
+    ErrorResponse,
+    INF_SCHEMA_COLUMNS_NAMES_SET,
+    RESPONSE_TYPE,
+)
 from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 
@@ -246,8 +251,7 @@ def test_native_query_with_results(self):
         mock_cursor.fetch_pandas_batches.assert_called_once()
         mock_cursor.fetchall.assert_not_called()
 
-        self.assertIsInstance(data, Response)
-        self.assertFalse(data.error_code)
+        self.assertIsInstance(data, TableResponse)
         self.assertEqual(data.type, RESPONSE_TYPE.TABLE)
         self.assertIsInstance(data.data_frame, DataFrame)
         self.assertListEqual(list(data.data_frame.columns), expected_columns)
@@ -285,8 +289,7 @@ def test_native_query_no_results(self):
         mock_cursor.execute.assert_called_once_with(query_str)
         mock_cursor.fetch_pandas_batches.assert_called_once()
 
-        self.assertIsInstance(data, Response)
-        self.assertFalse(data.error_code)
+        self.assertIsInstance(data, OkResponse)
         self.assertEqual(data.type, RESPONSE_TYPE.OK)
         self.assertEqual(data.affected_rows, 1)
 
@@ -350,7 +353,7 @@ def test_native_query_error(self):
         mock_conn.cursor.assert_called_once()
         mock_cursor.execute.assert_called_once_with(query_str)
 
-        self.assertIsInstance(data, Response)
+        self.assertIsInstance(data, ErrorResponse)
         self.assertEqual(data.type, RESPONSE_TYPE.ERROR)
         self.assertIn(error_msg, data.error_message)
 
@@ -376,33 +379,11 @@ def test_native_query_releases_memory_pool_when_jemalloc(self):
             mock_pool.backend_name = "jemalloc"
             mock_pool.release_unused = MagicMock()
 
-            response = self.handler.native_query("SELECT 1")
+            response = self.handler.native_query("SELECT 1", stream=False)
 
             self.assertEqual(response.type, RESPONSE_TYPE.TABLE)
             mock_pool.release_unused.assert_called_once()
 
-    def test_native_query_memory_estimation_error(self):
-        mock_conn = MagicMock()
-        mock_cursor = MagicMock()
-        mock_cursor.__enter__.return_value = mock_cursor
-        mock_cursor.__exit__.return_value = None
-        large_df = DataFrame({"ID": range(1500)})
-        mock_cursor.fetch_pandas_batches.return_value = iter([large_df])
-        mock_cursor.description = [ColumnDescription(name="ID", type_code=0, scale=0)]
-        mock_cursor.rowcount = 10000
-
-        self.handler.connect = MagicMock(return_value=mock_conn)
-        mock_conn.cursor.return_value = mock_cursor
-
-        with patch(
-            "mindsdb.integrations.handlers.snowflake_handler.snowflake_handler.psutil.virtual_memory",
-            return_value=SimpleNamespace(available=512),
-        ):
-            response = self.handler.native_query("SELECT * FROM big_table")
-
-        self.assertEqual(response.type, RESPONSE_TYPE.ERROR)
-        self.assertIn("query result is too large", response.error_message)
-
     def test_key_pair_authentication_success(self):
         """
         Tests successful connection using key pair authentication
@@ -645,7 +626,7 @@ def test_query_method(self):
         renderer_mock.get_string.return_value = "SELECT * FROM test_table_rendered"
 
         self.handler.native_query = MagicMock()
-        expected_response = Response(RESPONSE_TYPE.TABLE)
+        expected_response = TableResponse(data=DataFrame())
         self.handler.native_query.return_value = expected_response
 
         try:
@@ -673,11 +654,8 @@ def test_get_tables(self):
         """
         Tests that get_tables calls native_query with the correct SQL for Snowflake
         """
-        expected_response = Response(
-            RESPONSE_TYPE.TABLE,
-            data_frame=DataFrame(
-                [("table1", "SCHEMA1", "BASE TABLE")], columns=["TABLE_NAME", "TABLE_SCHEMA", "TABLE_TYPE"]
-            ),
+        expected_response = TableResponse(
+            data=DataFrame([("table1", "SCHEMA1", "BASE TABLE")], columns=["TABLE_NAME", "TABLE_SCHEMA", "TABLE_TYPE"])
         )
         self.handler.native_query = MagicMock(return_value=expected_response)
 
@@ -751,7 +729,7 @@ def test_get_columns(self):
         ]
         expected_df = DataFrame(expected_df_data, columns=query_columns)
 
-        expected_response = Response(RESPONSE_TYPE.TABLE, data_frame=expected_df)
+        expected_response = TableResponse(data=expected_df)
         self.handler.native_query = MagicMock(return_value=expected_response)
 
         table_name = "test_table"
@@ -794,7 +772,7 @@ def test_meta_get_tables_casts_rowcount(self):
                 }
             ]
         )
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=df))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=df))
 
         result = self.handler.meta_get_tables(table_names=["orders"])
 
@@ -815,7 +793,7 @@ def test_meta_get_columns_filters(self):
                 }
             ]
         )
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=df))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=df))
 
         result = self.handler.meta_get_columns(table_names=["orders"])
 
@@ -849,8 +827,8 @@ def test_meta_get_column_statistics_success(self):
         )
         self.handler.native_query = MagicMock(
             side_effect=[
-                Response(RESPONSE_TYPE.TABLE, data_frame=columns_df),
-                Response(RESPONSE_TYPE.TABLE, data_frame=stats_df),
+                TableResponse(data=columns_df),
+                TableResponse(data=stats_df),
             ]
         )
 
@@ -864,9 +842,7 @@ def test_meta_get_column_statistics_success(self):
         self.assertEqual(id_stats["maximum_value"], 10)
 
     def test_meta_get_column_statistics_handles_error_response(self):
-        self.handler.native_query = MagicMock(
-            return_value=Response(RESPONSE_TYPE.ERROR, error_message="boom", data_frame=None)
-        )
+        self.handler.native_query = MagicMock(return_value=ErrorResponse(error_message="boom"))
         result = self.handler.meta_get_column_statistics(table_names=["orders"])
         self.assertEqual(result.type, RESPONSE_TYPE.ERROR)
 
@@ -877,7 +853,7 @@ def test_meta_get_primary_keys_filters(self):
                 {"table_name": "CUSTOMERS", "column_name": "ID", "key_sequence": 1, "constraint_name": "PK_CUSTOMERS"},
             ]
         )
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=df))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=df))
 
         result = self.handler.meta_get_primary_keys(table_names=["ORDERS"])
 
@@ -909,12 +885,17 @@ def test_meta_get_foreign_keys_filters(self):
                 },
             ]
         )
-        self.handler.native_query = MagicMock(return_value=Response(RESPONSE_TYPE.TABLE, data_frame=df))
+        self.handler.native_query = MagicMock(return_value=TableResponse(data=df))
 
         result = self.handler.meta_get_foreign_keys(table_names=["ORDERS", "CUSTOMERS"])
 
         self.assertEqual(len(result.data_frame), 1)
         self.assertIn("child_table_name", result.data_frame.columns)
+        row = result.data_frame.iloc[0]
+        self.assertEqual(row["parent_table_name"], "ORDERS")
+        self.assertEqual(row["parent_column_name"], "CUSTOMER_ID")
+        self.assertEqual(row["child_table_name"], "CUSTOMERS")
+        self.assertEqual(row["child_column_name"], "ID")
 
     def test_meta_get_foreign_keys_handles_exception(self):
         self.handler.native_query = MagicMock(side_effect=Exception("boom"))
@@ -1195,7 +1176,8 @@ def test_types_casting(self):
         ]
 
         response = self.handler.native_query(query_str)
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        actual_mysql_types = [col.type for col in response.columns]
+        self.assertEqual(actual_mysql_types, excepted_mysql_types)
         for column_name in input_data.columns:
             result_value = response.data_frame[column_name][0]
             self.assertEqual(result_value, input_data[column_name][0])
@@ -1346,7 +1328,8 @@ def test_types_casting(self):
         ]
 
         response = self.handler.native_query(query_str)
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        actual_mysql_types = [col.type for col in response.columns]
+        self.assertEqual(actual_mysql_types, excepted_mysql_types)
         for column_name in input_data.columns:
             result_value = response.data_frame[column_name][0]
             self.assertEqual(result_value, input_data[column_name][0])
@@ -1380,7 +1363,8 @@ def test_types_casting(self):
         excepted_mysql_types = [MYSQL_DATA_TYPE.BOOLEAN]
 
         response = self.handler.native_query(query_str)
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        actual_mysql_types = [col.type for col in response.columns]
+        self.assertEqual(actual_mysql_types, excepted_mysql_types)
         for column_name in input_data.columns:
             result_value = response.data_frame[column_name][0]
             self.assertEqual(result_value, input_data[column_name][0])
@@ -1616,7 +1600,8 @@ def test_types_casting(self):
             }
         )
         response = self.handler.native_query(query_str)
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        actual_mysql_types = [col.type for col in response.columns]
+        self.assertEqual(actual_mysql_types, excepted_mysql_types)
         self.assertTrue(response.data_frame.equals(expected_result_df))
         # endregion
 
@@ -1679,7 +1664,8 @@ def test_types_casting(self):
             }
         )
         response = self.handler.native_query(query_str)
-        self.assertEqual(response.mysql_types, excepted_mysql_types)
+        actual_mysql_types = [col.type for col in response.columns]
+        self.assertEqual(actual_mysql_types, excepted_mysql_types)
         self.assertTrue(response.data_frame.equals(expected_result_df))
         # endregion
 
diff --git a/tests/unit/handlers/test_timescaledb.py b/tests/unit/handlers/test_timescaledb.py
index 32c3efb46de..52cbd771908 100644
--- a/tests/unit/handlers/test_timescaledb.py
+++ b/tests/unit/handlers/test_timescaledb.py
@@ -7,22 +7,19 @@
 
 from base_handler_test import BaseDatabaseHandlerTest, MockCursorContextManager
 from mindsdb.integrations.handlers.timescaledb_handler.timescaledb_handler import TimeScaleDBHandler
-from mindsdb.integrations.libs.response import (
-    HandlerResponse as Response
-)
+from mindsdb.integrations.libs.response import DataHandlerResponse as Response
 
 
 class TestTimescaleHandler(BaseDatabaseHandlerTest, unittest.TestCase):
-
     @property
     def dummy_connection_data(self):
         return OrderedDict(
-            host='127.0.0.1',
+            host="127.0.0.1",
             port=5432,
-            user='example_user',
-            schema='public',
-            password='example_pass',
-            database='example_db'
+            user="example_user",
+            schema="public",
+            password="example_pass",
+            database="example_db",
         )
 
     @property
@@ -69,10 +66,10 @@ def get_columns_query(self):
         """
 
     def create_handler(self):
-        return TimeScaleDBHandler('timescaledb', connection_data=self.dummy_connection_data)
+        return TimeScaleDBHandler("timescaledb", connection_data=self.dummy_connection_data)
 
     def create_patcher(self):
-        return patch('psycopg.connect')
+        return patch("psycopg.connect")
 
     def test_native_query(self):
         """
@@ -99,5 +96,5 @@ def test_native_query(self):
         self.assertFalse(data.error_code)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()
diff --git a/tests/unit/integrations/__init__.py b/tests/unit/integrations/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/unit/integrations/libs/__init__.py b/tests/unit/integrations/libs/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/unit/integrations/libs/test_response.py b/tests/unit/integrations/libs/test_response.py
new file mode 100644
index 00000000000..18aa870d939
--- /dev/null
+++ b/tests/unit/integrations/libs/test_response.py
@@ -0,0 +1,671 @@
+"""Unit tests for response classes in mindsdb.integrations.libs.response module.
+
+This module tests all response types used by handlers:
+- TableResponse: for queries that return data (SELECT, SHOW, etc.)
+- OkResponse: for successful operations without data (CREATE, DROP, etc.)
+- ErrorResponse: for error cases
+- HandlerStatusResponse: for connection status checks
+- normalize_response: for converting legacy HandlerResponse to new types
+- _safe_pandas_concat: memory-safe DataFrame concatenation
+"""
+
+from unittest.mock import patch, MagicMock
+
+import pandas as pd
+import pytest
+
+from mindsdb.integrations.libs.response import (
+    TableResponse,
+    OkResponse,
+    ErrorResponse,
+    HandlerStatusResponse,
+    HandlerResponse,
+    normalize_response,
+    _safe_pandas_concat,
+    RESPONSE_TYPE,
+    DataHandlerResponse,
+)
+from mindsdb.utilities.types.column import Column
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
+
+
+def _mock_virtual_memory(available_kb: int):
+    """Create a mock for psutil.virtual_memory() with given available memory in KB."""
+    mock_mem = MagicMock()
+    mock_mem.available = available_kb << 10  # convert KB back to bytes
+    return mock_mem
+
+
+class TestHandlerStatusResponse:
+    """Tests for HandlerStatusResponse class."""
+
+    def test_init_success(self):
+        """Test initialization with success status."""
+        redirect_url = "https://example.com/auth"
+        copy_storage = "s3://bucket/path"
+        response = HandlerStatusResponse(success=True, redirect_url=redirect_url, copy_storage=copy_storage)
+
+        assert response.success is True
+        assert response.error_message is None
+        assert response.redirect_url == redirect_url
+        assert response.copy_storage == copy_storage
+
+        json_data = response.to_json()
+        assert json_data["success"] is True
+        assert json_data["error"] is None
+        assert json_data["redirect_url"] == redirect_url
+        assert json_data["copy_storage"] == copy_storage
+
+    def test_init_failure(self):
+        """Test initialization with failure status."""
+        error_msg = "Connection failed"
+        response = HandlerStatusResponse(success=False, error_message=error_msg)
+
+        assert response.success is False
+        assert response.error_message == error_msg
+        assert response.redirect_url is None
+        assert response.copy_storage is None
+
+        json_data = response.to_json()
+        assert json_data["success"] is False
+        assert json_data["error"] == error_msg
+        assert "redirect_url" not in json_data
+        assert "copy_storage" not in json_data
+
+
+class TestErrorResponse:
+    """Unit tests for ErrorResponse class."""
+
+    def test_init_basic(self):
+        """Test basic initialization."""
+        response = ErrorResponse(error_code=1, error_message="Test error", is_expected_error=True)
+
+        assert response.type == RESPONSE_TYPE.ERROR
+        assert response.resp_type == RESPONSE_TYPE.ERROR
+        assert response.error_code == 1
+        assert response.error_message == "Test error"
+        assert response.is_expected_error is True
+        assert response.exception is None
+        assert isinstance(response, DataHandlerResponse)
+
+    def test_exception_capture(self):
+        """Test that exception is captured from current context."""
+        try:
+            raise ValueError("Test exception")
+        except ValueError:
+            response = ErrorResponse(error_message="Caught exception")
+            assert response.exception is not None
+            assert isinstance(response.exception, ValueError)
+
+
+class TestOkResponse:
+    """Unit tests for OkResponse class."""
+
+    def test_init(self):
+        """Test initialization with affected rows count."""
+        response = OkResponse(affected_rows=5)
+
+        assert response.type == RESPONSE_TYPE.OK
+        assert response.resp_type == RESPONSE_TYPE.OK
+        assert response.affected_rows == 5
+        assert isinstance(response, DataHandlerResponse)
+
+    def test_init_without_affected_rows(self):
+        """Test initialization without affected rows."""
+        response = OkResponse()
+
+        assert response.affected_rows is None
+
+
+class TestTableResponse:
+    """Unit tests for TableResponse class."""
+
+    def test_init_with_data(self):
+        """Test initialization with DataFrame."""
+        df = pd.DataFrame({"id": [1, 2, 3], "name": ["a", "b", "c"]})
+        response = TableResponse(data=df)
+
+        assert response.type == RESPONSE_TYPE.TABLE
+        assert response.resp_type == RESPONSE_TYPE.TABLE
+        assert response._fetched is True
+        pd.testing.assert_frame_equal(response._data, df)
+        # 'columns' was not provided as attr, so should be as in df
+        assert [c.name for c in response.columns] == ["id", "name"]
+
+    def test_complex_init_with_generator(self):
+        """Test initialization with data generator."""
+        column1 = Column(name="id", type=MYSQL_DATA_TYPE.INT)
+        column2 = Column(name="name", type=MYSQL_DATA_TYPE.VARCHAR)
+        columns = [column1, column2]
+        df = pd.DataFrame({"id": [0, 1], "name": ["a", "b"]})
+        df1 = pd.DataFrame({"id": [2, 3], "name": ["d", "e"]})
+        df2 = pd.DataFrame({"id": [4, 5], "name": ["f", "g"]})
+
+        def data_gen():
+            yield df1
+            yield df2
+
+        response = TableResponse(data=df, data_generator=data_gen(), columns=columns)
+
+        assert response.columns[0] is column1
+        assert response.columns[1] is column2
+        assert response.data_generator is not None
+        pd.testing.assert_frame_equal(response._data, df)
+        assert response._fetched is False
+        pieces = []
+        while isinstance(el := response.fetchmany(), pd.DataFrame):
+            pieces.append(el)
+        pd.testing.assert_frame_equal(pieces[0], df1)
+        pd.testing.assert_frame_equal(pieces[1], df2)
+        pd.testing.assert_frame_equal(response._data, pd.concat([df, df1, df2]))
+        assert response._fetched is True
+        assert response.data_generator is None
+
+    def test_data_frame_property(self):
+        """Test initialization with explicit columns."""
+        columns = [Column(name="id", type=MYSQL_DATA_TYPE.INT), Column(name="name", type=MYSQL_DATA_TYPE.VARCHAR)]
+        df = pd.DataFrame({"id": [0, 1], "name": ["a", "b"]})
+        df1 = pd.DataFrame({"id": [2, 3], "name": ["d", "e"]})
+        df2 = pd.DataFrame({"id": [4, 5], "name": ["f", "g"]})
+
+        def data_gen():
+            yield df1
+            yield df2
+
+        response = TableResponse(data=df, data_generator=data_gen(), columns=columns)
+        assert response._fetched is False
+        pd.testing.assert_frame_equal(response._data, df)
+        pd.testing.assert_frame_equal(response.data_frame, pd.concat([df, df1, df2]))
+        assert response._fetched is True
+
+        # should not change result
+        response.fetchall()
+        pd.testing.assert_frame_equal(response.data_frame, pd.concat([df, df1, df2]))
+
+    def test_init_with_affected_rows(self):
+        """Test initialization with affected_rows."""
+        df = pd.DataFrame({"id": [1, 2, 3]})
+        response = TableResponse(data=df, affected_rows=100)
+
+        assert response.affected_rows == 100
+
+    def test_iterate_no_save_no_generator(self):
+        """Test iterate_no_save yields existing data."""
+        df = pd.DataFrame({"id": [1, 2, 3]})
+        # Need to provide a generator (even empty) to avoid TypeError
+        response = TableResponse(data=df, data_generator=iter([]))
+
+        chunks = list(response.iterate_no_save())
+
+        assert len(chunks) == 1
+        pd.testing.assert_frame_equal(chunks[0], df)
+
+        # after `iterate_no_save` result should be invalid
+        with pytest.raises(ValueError):
+            pd.testing.assert_frame_equal(response.data_frame, df)
+
+    def test_iterate_no_save_with_generator(self):
+        """Test iterate_no_save yields all chunks without saving."""
+        df1 = pd.DataFrame({"id": [4, 5]})
+        df2 = pd.DataFrame({"id": [6, 7]})
+
+        def data_gen():
+            yield df1
+            yield df2
+
+        df = pd.DataFrame({"id": [1, 2, 3]})
+        response = TableResponse(data=df, data_generator=data_gen())
+        chunks = list(response.iterate_no_save())
+
+        assert len(chunks) == 3
+        pd.testing.assert_frame_equal(chunks[0], df)
+        pd.testing.assert_frame_equal(chunks[1], df1)
+        pd.testing.assert_frame_equal(chunks[2], df2)
+
+        # after `iterate_no_save` result should be invalid
+        with pytest.raises(ValueError):
+            pd.testing.assert_frame_equal(response.data_frame, df)
+
+
+class TestNormalizeResponse:
+    """Unit tests for normalize_response function."""
+
+    def test_normalize_table_response(self):
+        """Test that TableResponse is returned as-is."""
+        original = TableResponse(data=pd.DataFrame({"id": [1, 2]}))
+        result = normalize_response(original)
+
+        assert result is original
+
+    def test_normalize_ok_response(self):
+        """Test that OkResponse is returned as-is."""
+        original = OkResponse(affected_rows=5)
+        result = normalize_response(original)
+
+        assert result is original
+
+    def test_normalize_error_response(self):
+        """Test that ErrorResponse is returned as-is."""
+        original = ErrorResponse(error_message="Test error")
+        result = normalize_response(original)
+
+        assert result is original
+
+    def test_normalize_legacy_error_response(self):
+        """Test conversion of legacy HandlerResponse with ERROR type."""
+        legacy = HandlerResponse(resp_type=RESPONSE_TYPE.ERROR, error_code=1, error_message="Legacy error")
+        result = normalize_response(legacy)
+
+        assert isinstance(result, ErrorResponse)
+        assert result.error_code == 1
+        assert result.error_message == "Legacy error"
+
+    def test_normalize_legacy_ok_response(self):
+        """Test conversion of legacy HandlerResponse with OK type."""
+        legacy = HandlerResponse(resp_type=RESPONSE_TYPE.OK, affected_rows=10)
+        result = normalize_response(legacy)
+
+        assert isinstance(result, OkResponse)
+        assert result.affected_rows == 10
+
+    def test_normalize_legacy_table_response(self):
+        """Test conversion of legacy HandlerResponse with TABLE type."""
+        df = pd.DataFrame({"id": [1, 2], "name": ["a", "b"]})
+        legacy = HandlerResponse(resp_type=RESPONSE_TYPE.TABLE, data_frame=df)
+        result = normalize_response(legacy)
+
+        assert isinstance(result, TableResponse)
+        pd.testing.assert_frame_equal(result.data_frame, df)
+
+    def test_normalize_legacy_table_response_with_mysql_types(self):
+        """Test conversion preserves mysql_types as column types."""
+        df = pd.DataFrame({"id": [1, 2], "name": ["a", "b"]})
+        mysql_types = [MYSQL_DATA_TYPE.INT, MYSQL_DATA_TYPE.VARCHAR]
+        legacy = HandlerResponse(resp_type=RESPONSE_TYPE.TABLE, data_frame=df, mysql_types=mysql_types)
+        result = normalize_response(legacy)
+
+        assert isinstance(result, TableResponse)
+        assert len(result.columns) == 2
+        assert result.columns[0].type == MYSQL_DATA_TYPE.INT
+        assert result.columns[1].type == MYSQL_DATA_TYPE.VARCHAR
+
+    def test_normalize_legacy_table_response_empty_dataframe(self):
+        """Test conversion with empty DataFrame."""
+        df = pd.DataFrame()
+        legacy = HandlerResponse(resp_type=RESPONSE_TYPE.TABLE, data_frame=df)
+        result = normalize_response(legacy)
+
+        assert isinstance(result, TableResponse)
+        assert len(result.columns) == 0
+
+
+class TestSafePandasConcat:
+    """Unit tests for _safe_pandas_concat function."""
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_concat_with_enough_memory(self, mock_psutil):
+        """Test successful concatenation when sufficient memory is available."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+
+        df1 = pd.DataFrame({"id": [1, 2]})
+        df2 = pd.DataFrame({"id": [3, 4]})
+        result = _safe_pandas_concat([df1, df2])
+
+        pd.testing.assert_frame_equal(result, pd.concat([df1, df2]))
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_concat_raises_memory_error_when_not_enough_memory(self, mock_psutil):
+        """Test MemoryError is raised when available memory is too low."""
+        # Set available memory to essentially 0
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=10)
+
+        df1 = pd.DataFrame({"x": list(range(1000))})
+        df2 = pd.DataFrame({"x": list(range(1000))})
+
+        with pytest.raises(MemoryError):
+            _safe_pandas_concat([df1, df2])
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_concat_single_piece(self, mock_psutil):
+        """Test concatenation with a single DataFrame."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+
+        df = pd.DataFrame({"id": [1, 2, 3]})
+        result = _safe_pandas_concat([df])
+
+        pd.testing.assert_frame_equal(result, df)
+
+
+class TestRaiseIfLowMemory:
+    """Unit tests for TableResponse._raise_if_low_memory method."""
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_with_known_affected_rows_enough_memory(self, mock_psutil):
+        """Test no error when affected_rows is known and memory is sufficient."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+
+        response = TableResponse(data=pd.DataFrame({"id": [1, 2]}), affected_rows=100)
+        response._last_data_piece = pd.DataFrame({"id": list(range(10))})
+        response.rows_fetched = 10
+
+        # Should not raise
+        response._raise_if_low_memory()
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_with_known_affected_rows_not_enough_memory(self, mock_psutil):
+        """Test MemoryError when affected_rows is known and memory is insufficient."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1)
+
+        # Use strings to ensure DataFrame memory > 1KB after >> 10
+        large_piece = pd.DataFrame({"text": ["x" * 200 for _ in range(100)]})
+        response = TableResponse(data=pd.DataFrame({"text": ["a"]}), affected_rows=1000)
+        response._last_data_piece = large_piece
+        response.rows_fetched = 100
+
+        with pytest.raises(MemoryError, match="Not enough memory"):
+            response._raise_if_low_memory()
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_with_unknown_affected_rows_enough_memory(self, mock_psutil):
+        """Test no error when affected_rows is None and memory is sufficient."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+
+        response = TableResponse(data=pd.DataFrame({"id": [1, 2]}))
+        response._last_data_piece = pd.DataFrame({"id": list(range(10))})
+
+        # Should not raise
+        response._raise_if_low_memory()
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_with_unknown_affected_rows_not_enough_memory(self, mock_psutil):
+        """Test MemoryError when affected_rows is None and memory is insufficient."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1)
+
+        # Use strings to ensure DataFrame memory > 1KB after >> 10
+        large_piece = pd.DataFrame({"text": ["x" * 200 for _ in range(100)]})
+        response = TableResponse(data=pd.DataFrame({"text": ["a"]}))
+        response._last_data_piece = large_piece
+
+        with pytest.raises(MemoryError, match="Not enough memory"):
+            response._raise_if_low_memory()
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_all_rows_already_fetched(self, mock_psutil):
+        """Test no error when all rows have been fetched (rows_expected = 0)."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=0)
+
+        response = TableResponse(data=pd.DataFrame({"id": [1, 2]}), affected_rows=10)
+        response._last_data_piece = pd.DataFrame({"id": list(range(10))})
+        response.rows_fetched = 10  # all rows fetched
+
+        # rows_expected = min(10 - 10, 10) = 0, should not raise
+        response._raise_if_low_memory()
+
+
+class TestIterateWithMemoryCheck:
+    """Unit tests for TableResponse._iterate_with_memory_check method."""
+
+    def test_none_generator_yields_nothing(self):
+        """Test that no chunks are yielded when data_generator is None."""
+        response = TableResponse(data=pd.DataFrame({"id": [1]}))
+        assert response._data_generator is None
+
+        chunks = list(response._iterate_with_memory_check())
+        assert chunks == []
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_normal_iteration(self, mock_psutil):
+        """Test that all chunks are yielded during normal iteration."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+
+        df1 = pd.DataFrame({"id": [1, 2]})
+        df2 = pd.DataFrame({"id": [3, 4]})
+
+        def data_gen():
+            yield df1
+            yield df2
+
+        columns = [Column(name="id")]
+        response = TableResponse(data_generator=data_gen(), columns=columns)
+
+        chunks = list(response._iterate_with_memory_check())
+
+        assert len(chunks) == 2
+        pd.testing.assert_frame_equal(chunks[0], df1)
+        pd.testing.assert_frame_equal(chunks[1], df2)
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_memory_error_stops_iteration_after_first_chunk(self, mock_psutil):
+        """Test that MemoryError is raised after the first chunk when memory runs out.
+
+        The pre-loop _raise_if_low_memory() is a no-op (since _last_data_piece is None),
+        so the first real psutil.virtual_memory() call happens at the post-yield check.
+        """
+        # Use strings to ensure DataFrame memory > 1KB after >> 10
+        df1 = pd.DataFrame({"text": ["x" * 200 for _ in range(100)]})
+        df2 = pd.DataFrame({"text": ["y" * 200 for _ in range(100)]})
+
+        def data_gen():
+            yield df1
+            yield df2
+
+        columns = [Column(name="text")]
+        response = TableResponse(data_generator=data_gen(), columns=columns)
+
+        gen = response._iterate_with_memory_check()
+
+        # First chunk succeeds — post-yield check will be the first real psutil call
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1)
+        first = next(gen)
+        pd.testing.assert_frame_equal(first, df1)
+
+        # Resuming the generator triggers _raise_if_low_memory with 0 available memory
+        with pytest.raises(MemoryError):
+            next(gen)
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_updates_last_data_piece_and_rows_fetched(self, mock_psutil):
+        """Test that _last_data_piece and rows_fetched are updated during iteration."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+
+        df1 = pd.DataFrame({"id": [1, 2, 3]})
+        df2 = pd.DataFrame({"id": [4, 5]})
+
+        def data_gen():
+            yield df1
+            yield df2
+
+        columns = [Column(name="id")]
+        response = TableResponse(data_generator=data_gen(), columns=columns)
+        assert response.rows_fetched == 0
+
+        list(response._iterate_with_memory_check())
+
+        pd.testing.assert_frame_equal(response._last_data_piece, df2)
+        assert response.rows_fetched == 5
+
+
+class TestTableResponseFetchallEdgeCases:
+    """Additional edge-case tests for TableResponse.fetchall."""
+
+    def test_fetchall_no_generator_returns_existing_data(self):
+        """Test fetchall returns existing data when no generator is set."""
+        df = pd.DataFrame({"id": [1, 2, 3]})
+        response = TableResponse(data=df)
+
+        result = response.fetchall()
+        pd.testing.assert_frame_equal(result, df)
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_fetchall_generator_only_no_initial_data(self, mock_psutil):
+        """Test fetchall with generator but no initial data."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+
+        df1 = pd.DataFrame({"id": [1, 2]})
+        df2 = pd.DataFrame({"id": [3, 4]})
+
+        def data_gen():
+            yield df1
+            yield df2
+
+        columns = [Column(name="id")]
+        response = TableResponse(data_generator=data_gen(), columns=columns)
+
+        result = response.fetchall()
+        pd.testing.assert_frame_equal(result, pd.concat([df1, df2]))
+        assert response._fetched is True
+        assert response._data_generator is None
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_fetchall_empty_generator_creates_empty_df(self, mock_psutil):
+        """Test fetchall with empty generator creates DataFrame with column names."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+
+        columns = [Column(name="id"), Column(name="name")]
+        response = TableResponse(data_generator=iter([]), columns=columns)
+
+        result = response.fetchall()
+        assert list(result.columns) == ["id", "name"]
+        assert len(result) == 0
+
+    def test_fetchall_raises_if_invalid(self):
+        """Test fetchall raises ValueError if data was already consumed by iterate_no_save."""
+        df = pd.DataFrame({"id": [1]})
+        response = TableResponse(data=df, data_generator=iter([]))
+        list(response.iterate_no_save())
+
+        with pytest.raises(ValueError, match="Data has already been fetched"):
+            response.fetchall()
+
+
+class TestTableResponseFetchmanyEdgeCases:
+    """Additional edge-case tests for TableResponse.fetchmany."""
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_fetchmany_first_piece_with_no_initial_data(self, mock_psutil):
+        """Test fetchmany sets _data directly when no initial data exists."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+
+        df1 = pd.DataFrame({"id": [1, 2]})
+        columns = [Column(name="id")]
+        response = TableResponse(data_generator=iter([df1]), columns=columns)
+
+        piece = response.fetchmany()
+        pd.testing.assert_frame_equal(piece, df1)
+        pd.testing.assert_frame_equal(response._data, df1)
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_fetchmany_accumulates_data(self, mock_psutil):
+        """Test fetchmany accumulates pieces in _data."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+
+        df = pd.DataFrame({"id": [0]})
+        df1 = pd.DataFrame({"id": [1]})
+        df2 = pd.DataFrame({"id": [2]})
+
+        def data_gen():
+            yield df1
+            yield df2
+
+        columns = [Column(name="id")]
+        response = TableResponse(data=df, data_generator=data_gen(), columns=columns)
+
+        response.fetchmany()  # df1
+        response.fetchmany()  # df2
+
+        pd.testing.assert_frame_equal(response._data, pd.concat([df, df1, df2]))
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_fetchmany_returns_none_when_exhausted(self, mock_psutil):
+        """Test fetchmany returns None and marks response as fetched when generator is empty."""
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+
+        df1 = pd.DataFrame({"id": [1]})
+        columns = [Column(name="id")]
+        response = TableResponse(data_generator=iter([df1]), columns=columns)
+
+        piece1 = response.fetchmany()
+        assert isinstance(piece1, pd.DataFrame)
+
+        piece2 = response.fetchmany()
+        assert piece2 is None
+        assert response._fetched is True
+        assert response._data_generator is None
+
+    def test_fetchmany_raises_if_invalid(self):
+        """Test fetchmany raises ValueError after iterate_no_save."""
+        df = pd.DataFrame({"id": [1]})
+        response = TableResponse(data=df, data_generator=iter([]))
+        list(response.iterate_no_save())
+
+        with pytest.raises(ValueError, match="Data has already been fetched"):
+            response.fetchmany()
+
+
+class TestMemoryErrorPropagation:
+    """Tests for MemoryError propagation through fetchall, fetchmany, and iterate_no_save."""
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_fetchall_raises_memory_error(self, mock_psutil):
+        """Test MemoryError propagates through fetchall."""
+        # Enough memory for first chunk, then out of memory
+        mock_psutil.virtual_memory.side_effect = [
+            _mock_virtual_memory(available_kb=1_000_000),  # pre-loop check
+            _mock_virtual_memory(available_kb=0),  # post-yield check
+        ]
+
+        df1 = pd.DataFrame({"x": list(range(1000))})
+        df2 = pd.DataFrame({"x": list(range(1000))})
+
+        def data_gen():
+            yield df1
+            yield df2
+
+        columns = [Column(name="x")]
+        response = TableResponse(data_generator=data_gen(), columns=columns)
+
+        with pytest.raises(MemoryError):
+            response.fetchall()
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_fetchmany_raises_memory_error(self, mock_psutil):
+        """Test MemoryError propagates through fetchmany on second call."""
+        df1 = pd.DataFrame({"x": list(range(1000))})
+        df2 = pd.DataFrame({"x": list(range(1000))})
+
+        def data_gen():
+            yield df1
+            yield df2
+
+        columns = [Column(name="x")]
+        response = TableResponse(data_generator=data_gen(), columns=columns)
+
+        # First fetchmany: enough memory (pre-loop check is no-op since _last_data_piece is None)
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=1_000_000)
+        response.fetchmany()
+
+        # Second fetchmany: pre-loop check fails because we now have _last_data_piece set
+        mock_psutil.virtual_memory.return_value = _mock_virtual_memory(available_kb=0)
+        with pytest.raises(MemoryError):
+            response.fetchmany()
+
+    @patch("mindsdb.integrations.libs.response.psutil")
+    def test_iterate_no_save_raises_memory_error(self, mock_psutil):
+        """Test MemoryError propagates through iterate_no_save."""
+        mock_psutil.virtual_memory.side_effect = [
+            _mock_virtual_memory(available_kb=1_000_000),  # pre-loop check
+            _mock_virtual_memory(available_kb=0),  # post-yield check after first chunk
+        ]
+
+        df1 = pd.DataFrame({"x": list(range(1000))})
+        df2 = pd.DataFrame({"x": list(range(1000))})
+
+        def data_gen():
+            yield df1
+            yield df2
+
+        columns = [Column(name="x")]
+        response = TableResponse(data_generator=data_gen(), columns=columns)
+
+        with pytest.raises(MemoryError):
+            list(response.iterate_no_save())
diff --git a/tests/unit/interfaces/agents/test_generic_api_key.py b/tests/unit/interfaces/agents/test_generic_api_key.py
index 8198b763a08..3473aa05c70 100644
--- a/tests/unit/interfaces/agents/test_generic_api_key.py
+++ b/tests/unit/interfaces/agents/test_generic_api_key.py
@@ -1,9 +1,8 @@
 import os
 import unittest
-from unittest.mock import patch, MagicMock
+from unittest.mock import patch
 
 from mindsdb.integrations.utilities.handler_utils import get_api_key
-from mindsdb.interfaces.agents.agents_controller import AgentsController
 
 
 class TestGenericApiKeyHandling(unittest.TestCase):
@@ -71,100 +70,6 @@ def test_get_generic_api_key_for_google_provider(self):
         )
         self.assertEqual(api_key, "test-specific-google-api-key")
 
-    @patch("mindsdb.interfaces.agents.agents_controller.AgentsController.check_model_provider")
-    @patch("mindsdb.interfaces.agents.agents_controller.AgentsController.get_agent")
-    @patch("mindsdb.interfaces.agents.agents_controller.ProjectController")
-    @patch("mindsdb.interfaces.storage.db.session")
-    def test_add_agent_with_generic_api_key(
-        self, mock_session, mock_project_controller, mock_get_agent, mock_check_model_provider
-    ):
-        """Test adding an agent with a generic API key in params."""
-        # Mock project controller
-        mock_project = MagicMock()
-        mock_project_controller.return_value.get.return_value = mock_project
-
-        # Mock get_agent to return None (agent doesn't exist yet)
-        mock_get_agent.return_value = None
-
-        # Mock check_model_provider to return a provider
-        mock_check_model_provider.return_value = (None, "openai")
-
-        # Create an instance of AgentsController
-        agent_controller = AgentsController()
-
-        # Test adding an agent with a generic API key in params
-        params = {"api_key": "test-generic-agent-api-key", "other_param": "value"}
-
-        # Create a mock agent with proper params
-        mock_agent = MagicMock()
-        mock_agent.params = params.copy()  # Set params directly
-
-        # Mock db.Agents to return our prepared mock agent
-        with patch("mindsdb.interfaces.storage.db.Agents", return_value=mock_agent):
-            # Add the agent
-            agent = agent_controller.add_agent(
-                name="test_agent",
-                project_name="mindsdb",
-                model_name="gpt-4",
-                provider="openai",
-                params=params,
-            )
-
-        # Verify that the generic API key was preserved in the params
-        self.assertEqual(agent.params["api_key"], "test-generic-agent-api-key")
-
-    @patch("mindsdb.interfaces.agents.agents_controller.AgentsController.check_model_provider")
-    @patch("mindsdb.interfaces.agents.agents_controller.AgentsController.get_agent")
-    @patch("mindsdb.interfaces.agents.agents_controller.ProjectController")
-    @patch("mindsdb.interfaces.storage.db.session")
-    def test_add_agent_with_both_api_keys(
-        self, mock_session, mock_project_controller, mock_get_agent, mock_check_model_provider
-    ):
-        """Test adding an agent with both generic and provider-specific API keys."""
-        # Mock project controller
-        mock_project = MagicMock()
-        mock_project_controller.return_value.get.return_value = mock_project
-
-        # Mock get_agent to return None (agent doesn't exist yet)
-        mock_get_agent.return_value = None
-
-        # Mock check_model_provider to return a provider
-        mock_check_model_provider.return_value = (None, "openai")
-
-        # Create an instance of AgentsController
-        agent_controller = AgentsController()
-
-        # Test adding an agent with both generic and provider-specific API keys
-        params = {
-            "api_key": "test-generic-agent-api-key",
-            "openai_api_key": "test-specific-agent-api-key",
-            "other_param": "value",
-        }
-
-        # Create a mock agent with proper params
-        mock_agent = MagicMock()
-        mock_agent.params = params.copy()  # Set params directly
-
-        # Mock db.Agents to return our prepared mock agent
-        with patch("mindsdb.interfaces.storage.db.Agents", return_value=mock_agent):
-            # Add the agent
-            agent = agent_controller.add_agent(
-                name="test_agent",
-                project_name="mindsdb",
-                model_name="gpt-4",
-                provider="openai",
-                params=params,
-            )
-
-        # Verify that both API keys were preserved in the params
-        self.assertEqual(agent.params["api_key"], "test-generic-agent-api-key")
-        self.assertEqual(agent.params["openai_api_key"], "test-specific-agent-api-key")
-
-        # Test that get_api_key returns the provider-specific key when both are present
-        api_key = get_api_key("openai", {"params": params})
-
-        self.assertEqual(api_key, "test-specific-agent-api-key")
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/unit/interfaces/knowledge_base/test_default_storage_resolution.py b/tests/unit/interfaces/knowledge_base/test_default_storage_resolution.py
new file mode 100644
index 00000000000..6543ef28f4a
--- /dev/null
+++ b/tests/unit/interfaces/knowledge_base/test_default_storage_resolution.py
@@ -0,0 +1,79 @@
+import os
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+from mindsdb.interfaces.knowledge_base.controller import KnowledgeBaseController
+from mindsdb.interfaces.knowledge_base.default_storage_resolver import resolve_default_storage_engines
+from mindsdb.utilities.config import config
+
+
+def _make_controller(handler_meta_by_name):
+    integration_controller = MagicMock()
+    integration_controller.get_handler_meta.side_effect = lambda name: handler_meta_by_name.get(name)
+    integration_controller.get.return_value = None
+
+    session = SimpleNamespace(integration_controller=integration_controller)
+    return KnowledgeBaseController(session), integration_controller
+
+
+def test_resolve_default_vector_storage_uses_pgvector_from_config():
+    previous_storage = config["knowledge_bases"].get("storage", None)
+    controller, _ = _make_controller({"pgvector": {"import": {"success": True}}})
+
+    try:
+        config.update({"knowledge_bases": {"storage": "pgvector"}})
+        vector_db_name = "kb_pgvector_store"
+        controller._create_persistent_pgvector = MagicMock(return_value=vector_db_name)
+
+        vector_db, vector_table = controller._resolve_default_vector_storage("kb_docs")
+
+        assert vector_db == vector_db_name
+        assert vector_table == "kb_docs"
+        controller._create_persistent_pgvector.assert_called_once_with({})
+    finally:
+        config.update({"knowledge_bases": {"storage": previous_storage}})
+
+
+def test_resolve_default_vector_storage_uses_faiss_from_config():
+    previous_storage = config["knowledge_bases"].get("storage", None)
+    controller, _ = _make_controller({"duckdb_faiss": {"import": {"success": True}}})
+
+    try:
+        config.update({"knowledge_bases": {"storage": "faiss"}})
+
+        vector_db_name = "store_kb_docs"
+        controller._create_persistent_faiss = MagicMock(return_value=vector_db_name)
+
+        vector_db, vector_table = controller._resolve_default_vector_storage("kb_docs")
+
+        assert vector_db == vector_db_name
+        assert vector_table == "kb_docs"
+        controller._create_persistent_faiss.assert_called_once_with("kb_docs")
+    finally:
+        config.update({"knowledge_bases": {"storage": previous_storage}})
+
+
+def test_create_persistent_pgvector_reuses_existing_store():
+    controller, integration_controller = _make_controller({})
+    integration_controller.get.return_value = {"name": "kb_pgvector_store"}
+
+    vector_store_name = controller._create_persistent_pgvector({"is_sparse": True, "vector_size": 30522})
+
+    assert vector_store_name == "kb_pgvector_store"
+    integration_controller.add.assert_not_called()
+
+
+def test_resolver_uses_pgvector_url_fallback_when_storage_is_empty():
+    previous_storage = config["knowledge_bases"].get("storage", None)
+    controller, _ = _make_controller({})
+
+    try:
+        config.update({"knowledge_bases": {"storage": None}})
+        with patch.dict(os.environ, {"KB_PGVECTOR_URL": "postgresql://user:pass@host/db"}, clear=False):
+            resolved = resolve_default_storage_engines(config)
+            assert resolved["default_storage"] == "pgvector"
+            assert resolved["available_vector_engines"] == ["faiss", "pgvector"]
+            assert resolved["pgvector_enabled"] is True
+    finally:
+        config.update({"knowledge_bases": {"storage": previous_storage}})
diff --git a/tests/unit/planner/test_join_tables.py b/tests/unit/planner/test_join_tables.py
index 24cef73b8fa..7bd8a463d7a 100644
--- a/tests/unit/planner/test_join_tables.py
+++ b/tests/unit/planner/test_join_tables.py
@@ -11,6 +11,7 @@
     Star,
     BinaryOperation,
     Function,
+    Parameter,
 )
 from mindsdb_sql_parser.utils import JoinType
 
@@ -319,43 +320,71 @@ def test_join_tables_plan_limit_offset(self):
 
     def test_join_tables_plan_order_by(self):
         query = parse_sql("""
+            WITH tab2 AS (
+                SELECT * FROM int2.tab2 limit 100
+            ),            
+            categories as (
+                SELECT * FROM int3.cats
+            )        
             SELECT 
               tab1.column1, tab2.column1, tab2.column2 
-            FROM int.tab1 INNER 
-             JOIN int2.tab2 ON tab1.column1 > tab2.column1 
+            FROM  int.tab1 tab1
+            INNER JOIN tab2 ON tab1.column1 > tab2.column1 
+             WHERE tab2.category_id = (SELECT id FROM categories WHERE name='book')
             ORDER BY tab1.column1 
             LIMIT 10 
         """)
 
         subquery = copy.deepcopy(query)
+        subquery.cte = None
         subquery.from_table = None
         subquery.offset = None
+        subquery.where.args[1] = Parameter(Result(2))
 
-        plan = plan_query(query, integrations=["int", "int2"])
+        plan = plan_query(query, integrations=["int", "int2", "int3"], default_namespace="mindsdb")
         expected_plan = QueryPlan(
             integrations=["int"],
             steps=[
-                FetchDataframeStepPartition(
+                FetchDataframeStep(
                     step_num=0,
+                    integration="int2",
+                    query=parse_sql("select * from tab2 limit 100"),
+                ),
+                FetchDataframeStep(
+                    step_num=1,
+                    integration="int3",
+                    query=parse_sql("select * from cats"),
+                ),
+                SubSelectStep(
+                    step_num=2,
+                    query=Select(
+                        targets=[Identifier("id")],
+                        where=BinaryOperation(op="=", args=[Identifier("name"), Constant("book")]),
+                    ),
+                    dataframe=Result(1),
+                    table_name="categories",
+                ),
+                FetchDataframeStepPartition(
+                    step_num=3,
                     integration="int",
-                    query=parse_sql("select column1 AS column1 from tab1 order by column1"),
+                    query=parse_sql("select column1 AS column1 from tab1 AS tab1 order by column1"),
                     condition={"limit": 10},
                     steps=[
-                        FetchDataframeStep(
-                            step_num=1,
-                            integration="int2",
+                        SubSelectStep(
+                            step_num=4,
+                            dataframe=Result(0),
                             query=Select(
                                 targets=[
-                                    Identifier("column1", alias=Identifier("column1")),
-                                    Identifier("column2", alias=Identifier("column2")),
+                                    Star(),
                                 ],  # Column pruning
-                                from_table=Identifier("tab2"),
+                                where=BinaryOperation(op="=", args=[Identifier("category_id"), Parameter(Result(2))]),
                             ),
+                            table_name="tab2",
                         ),
                         JoinStep(
-                            step_num=2,
-                            left=Result(0),
-                            right=Result(1),
+                            step_num=5,
+                            left=Result(3),
+                            right=Result(4),
                             query=Join(
                                 left=Identifier("tab1"),
                                 right=Identifier("tab2"),
@@ -367,7 +396,7 @@ def test_join_tables_plan_order_by(self):
                         ),
                     ],
                 ),
-                QueryStep(subquery, from_table=Result(0), strict_where=False),
+                QueryStep(subquery, from_table=Result(3), strict_where=False),
             ],
         )
 
diff --git a/tests/unit/planner/test_select_from_predictor.py b/tests/unit/planner/test_select_from_predictor.py
index 38a1e65f1ff..85ccf4af365 100644
--- a/tests/unit/planner/test_select_from_predictor.py
+++ b/tests/unit/planner/test_select_from_predictor.py
@@ -1,14 +1,17 @@
 import pytest
 
 from mindsdb_sql_parser import parse_sql
-from mindsdb_sql_parser.ast import (Identifier, Select, Constant, Star, Parameter, BinaryOperation)
+from mindsdb_sql_parser.ast import Identifier, Select, Constant, Star, Parameter, BinaryOperation
 
 from mindsdb.api.executor.planner.exceptions import PlanningException
 from mindsdb.api.executor.planner import plan_query
 from mindsdb.api.executor.planner.query_plan import QueryPlan
 from mindsdb.api.executor.planner.step_result import Result
 from mindsdb.api.executor.planner.steps import (
-    ProjectStep, ApplyPredictorRowStep, GetPredictorColumns, FetchDataframeStep
+    ProjectStep,
+    ApplyPredictorRowStep,
+    GetPredictorColumns,
+    FetchDataframeStep,
 )
 
 
@@ -16,347 +19,334 @@ class TestPlanSelectFromPredictor:
     def test_select_from_predictor_plan(self):
         query = Select(
             targets=[Star()],
-            from_table=Identifier('mindsdb.pred'),
+            from_table=Identifier("mindsdb.pred"),
             where=BinaryOperation(
-                op='and',
-                args=[BinaryOperation(op='=', args=[Identifier('x1'), Constant(1)]),
-                      BinaryOperation(op='=', args=[Identifier('x2'), Constant('2')])],
-            )
+                op="and",
+                args=[
+                    BinaryOperation(op="=", args=[Identifier("x1"), Constant(1)]),
+                    BinaryOperation(op="=", args=[Identifier("x2"), Constant("2")]),
+                ],
+            ),
         )
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
+            predictor_namespace="mindsdb",
             steps=[
-                ApplyPredictorRowStep(
-                    namespace='mindsdb', predictor=Identifier('pred'),
-                    row_dict={'x1': 1, 'x2': '2'}
-                ),
+                ApplyPredictorRowStep(namespace="mindsdb", predictor=Identifier("pred"), row_dict={"x1": 1, "x2": "2"}),
             ],
-
         )
 
-        plan = plan_query(query, predictor_namespace='mindsdb', predictor_metadata={'pred': {}})
+        plan = plan_query(query, predictor_namespace="mindsdb", predictor_metadata={"pred": {}})
 
         assert plan.steps == expected_plan.steps
 
     def test_select_from_predictor_negative_constant(self):
         query = parse_sql(
-            '''
+            """
                         select * from mindsdb.pred
                         where x1 = -1
-                    '''
+                    """
         )
 
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
+            predictor_namespace="mindsdb",
             steps=[
-                ApplyPredictorRowStep(namespace='mindsdb', predictor=Identifier('pred'), row_dict={'x1': -1, }),
+                ApplyPredictorRowStep(
+                    namespace="mindsdb",
+                    predictor=Identifier("pred"),
+                    row_dict={
+                        "x1": -1,
+                    },
+                ),
             ],
         )
 
-        plan = plan_query(query, predictor_namespace='mindsdb', predictor_metadata={'pred': {}})
+        plan = plan_query(query, predictor_namespace="mindsdb", predictor_metadata={"pred": {}})
 
         assert plan.steps == expected_plan.steps
 
     def test_select_from_predictor_plan_other_ml(self):
         query = parse_sql(
-            '''
+            """
                         select * from mlflow.pred
                         where x1 = 1 and x2 = '2'
-                    '''
+                    """
         )
 
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
+            predictor_namespace="mindsdb",
             steps=[
-                ApplyPredictorRowStep(
-                    namespace='mlflow', predictor=Identifier('pred'),
-                    row_dict={'x1': 1, 'x2': '2'}
-                ),
+                ApplyPredictorRowStep(namespace="mlflow", predictor=Identifier("pred"), row_dict={"x1": 1, "x2": "2"}),
             ],
-
         )
 
-        plan = plan_query(query, predictor_metadata=[{'name': 'pred', 'integration_name': 'mlflow'}])
+        plan = plan_query(query, predictor_metadata=[{"name": "pred", "integration_name": "mlflow"}])
 
         assert plan.steps == expected_plan.steps
 
     def test_select_from_predictor_aliases_in_project(self):
         query = Select(
-            targets=[Identifier('tb.x1', alias=Identifier('col1')),
-                     Identifier('tb.x2', alias=Identifier('col2')),
-                     Identifier('tb.y', alias=Identifier('predicted'))],
-            from_table=Identifier('mindsdb.pred', alias=Identifier('tb')),
+            targets=[
+                Identifier("tb.x1", alias=Identifier("col1")),
+                Identifier("tb.x2", alias=Identifier("col2")),
+                Identifier("tb.y", alias=Identifier("predicted")),
+            ],
+            from_table=Identifier("mindsdb.pred", alias=Identifier("tb")),
             where=BinaryOperation(
-                op='and',
+                op="and",
                 args=[
-                    BinaryOperation(op='=', args=[Identifier('tb.x1'), Constant(1)]),
-                    BinaryOperation(op='=', args=[Identifier('tb.x2'), Constant('2')]),
+                    BinaryOperation(op="=", args=[Identifier("tb.x1"), Constant(1)]),
+                    BinaryOperation(op="=", args=[Identifier("tb.x2"), Constant("2")]),
                 ],
-            )
+            ),
         )
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
+            predictor_namespace="mindsdb",
             steps=[
                 ApplyPredictorRowStep(
-                    namespace='mindsdb',
-                    predictor=Identifier('pred', alias=Identifier('tb')),
-                    row_dict={'x1': 1, 'x2': '2'}
+                    namespace="mindsdb",
+                    predictor=Identifier("pred", alias=Identifier("tb")),
+                    row_dict={"x1": 1, "x2": "2"},
                 ),
                 ProjectStep(
                     dataframe=Result(0),
-                    columns=[Identifier('tb.x1', alias=Identifier('col1')),
-                             Identifier('tb.x2', alias=Identifier('col2')),
-                             Identifier('tb.y', alias=Identifier('predicted'))]
+                    columns=[
+                        Identifier("tb.x1", alias=Identifier("col1")),
+                        Identifier("tb.x2", alias=Identifier("col2")),
+                        Identifier("tb.y", alias=Identifier("predicted")),
+                    ],
                 ),
             ],
-
         )
 
-        plan = plan_query(query, predictor_namespace='mindsdb', predictor_metadata={'pred': {}})
+        plan = plan_query(query, predictor_namespace="mindsdb", predictor_metadata={"pred": {}})
 
         assert plan.steps == expected_plan.steps
 
     def test_select_from_predictor_plan_predictor_alias(self):
         query = Select(
             targets=[Star()],
-            from_table=Identifier('mindsdb.pred', alias=Identifier('pred_alias')),
+            from_table=Identifier("mindsdb.pred", alias=Identifier("pred_alias")),
             where=BinaryOperation(
-                op='and',
+                op="and",
                 args=[
-                    BinaryOperation(op='=', args=[Identifier('pred_alias.x1'), Constant(1)]),
-                    BinaryOperation(
-                        op='=',
-                        args=[Identifier('pred_alias.x2'), Constant('2')]
-                    )
+                    BinaryOperation(op="=", args=[Identifier("pred_alias.x1"), Constant(1)]),
+                    BinaryOperation(op="=", args=[Identifier("pred_alias.x2"), Constant("2")]),
                 ],
-            )
+            ),
         )
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
+            predictor_namespace="mindsdb",
             steps=[
                 ApplyPredictorRowStep(
-                    namespace='mindsdb', predictor=Identifier('pred', alias=Identifier('pred_alias')),
-                    row_dict={'x1': 1, 'x2': '2'}
+                    namespace="mindsdb",
+                    predictor=Identifier("pred", alias=Identifier("pred_alias")),
+                    row_dict={"x1": 1, "x2": "2"},
                 ),
             ],
         )
 
-        plan = plan_query(query, predictor_namespace='mindsdb', predictor_metadata={'pred': {}})
+        plan = plan_query(query, predictor_namespace="mindsdb", predictor_metadata={"pred": {}})
 
         assert plan.steps == expected_plan.steps
 
     def test_select_from_predictor_plan_verbose_col_names(self):
         query = Select(
             targets=[Star()],
-            from_table=Identifier('mindsdb.pred'),
+            from_table=Identifier("mindsdb.pred"),
             where=BinaryOperation(
-                op='and',
-                args=[BinaryOperation(op='=', args=[Identifier('pred.x1'), Constant(1)]),
-                      BinaryOperation(op='=', args=[Identifier('pred.x2'), Constant('2')])],
-            )
+                op="and",
+                args=[
+                    BinaryOperation(op="=", args=[Identifier("pred.x1"), Constant(1)]),
+                    BinaryOperation(op="=", args=[Identifier("pred.x2"), Constant("2")]),
+                ],
+            ),
         )
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
+            predictor_namespace="mindsdb",
             steps=[
-                ApplyPredictorRowStep(
-                    namespace='mindsdb', predictor=Identifier('pred'),
-                    row_dict={'x1': 1, 'x2': '2'}
-                ),
+                ApplyPredictorRowStep(namespace="mindsdb", predictor=Identifier("pred"), row_dict={"x1": 1, "x2": "2"}),
                 ProjectStep(dataframe=Result(0), columns=[Star()]),
             ],
         )
 
-        plan = plan_query(query, predictor_namespace='mindsdb', predictor_metadata={'pred': {}})
+        plan = plan_query(query, predictor_namespace="mindsdb", predictor_metadata={"pred": {}})
 
         for i in range(len(plan.steps)):
             assert plan.steps[i] == expected_plan.steps[i]
 
     def test_select_from_predictor_plan_group_by_error(self):
         query = Select(
-            targets=[Identifier('x1'), Identifier('x2'), Identifier('pred.y')],
-            from_table=Identifier('mindsdb.pred'),
-            group_by=[Identifier('x1')]
+            targets=[Identifier("x1"), Identifier("x2"), Identifier("pred.y")],
+            from_table=Identifier("mindsdb.pred"),
+            group_by=[Identifier("x1")],
         )
         with pytest.raises(PlanningException):
-            plan_query(query, predictor_namespace='mindsdb', predictor_metadata={'pred': {}})
+            plan_query(query, predictor_namespace="mindsdb", predictor_metadata={"pred": {}})
 
     def test_select_from_predictor_wrong_where_op_error(self):
         query = Select(
             targets=[Star()],
-            from_table=Identifier('mindsdb.pred'),
+            from_table=Identifier("mindsdb.pred"),
             where=BinaryOperation(
-                op='and',
-                args=[BinaryOperation(op='>', args=[Identifier('x1'), Constant(1)]),
-                      BinaryOperation(op='=', args=[Identifier('x2'), Constant('2')])],
-            )
+                op="and",
+                args=[
+                    BinaryOperation(op=">", args=[Identifier("x1"), Constant(1)]),
+                    BinaryOperation(op="=", args=[Identifier("x2"), Constant("2")]),
+                ],
+            ),
         )
 
         with pytest.raises(PlanningException):
-            plan_query(query, predictor_namespace='mindsdb', predictor_metadata={'pred': {}})
+            plan_query(query, predictor_namespace="mindsdb", predictor_metadata={"pred": {}})
 
     def test_select_from_predictor_multiple_values_error(self):
         query = Select(
             targets=[Star()],
-            from_table=Identifier('mindsdb.pred'),
+            from_table=Identifier("mindsdb.pred"),
             where=BinaryOperation(
-                op='and',
-                args=[BinaryOperation(op='=', args=[Identifier('x1'), Constant(1)]),
-                      BinaryOperation(op='=', args=[Identifier('x1'), Constant('2')])],
-            )
+                op="and",
+                args=[
+                    BinaryOperation(op="=", args=[Identifier("x1"), Constant(1)]),
+                    BinaryOperation(op="=", args=[Identifier("x1"), Constant("2")]),
+                ],
+            ),
         )
 
         with pytest.raises(PlanningException):
-            plan_query(query, predictor_namespace='mindsdb', predictor_metadata={'pred': {}})
+            plan_query(query, predictor_namespace="mindsdb", predictor_metadata={"pred": {}})
 
     def test_select_from_predictor_no_where_error(self):
-        query = Select(
-            targets=[Star()],
-            from_table=Identifier('mindsdb.pred')
-        )
+        query = Select(targets=[Star()], from_table=Identifier("mindsdb.pred"))
 
         with pytest.raises(PlanningException):
-            plan_query(query, predictor_namespace='mindsdb', predictor_metadata={'pred': {}})
+            plan_query(query, predictor_namespace="mindsdb", predictor_metadata={"pred": {}})
 
     def test_select_from_predictor_default_namespace(self):
         query = Select(
             targets=[Star()],
-            from_table=Identifier('pred'),
+            from_table=Identifier("pred"),
             where=BinaryOperation(
-                op='and',
-                args=[BinaryOperation(op='=', args=[Identifier('x1'), Constant(1)]),
-                      BinaryOperation(op='=', args=[Identifier('x2'), Constant('2')])],
-            )
+                op="and",
+                args=[
+                    BinaryOperation(op="=", args=[Identifier("x1"), Constant(1)]),
+                    BinaryOperation(op="=", args=[Identifier("x2"), Constant("2")]),
+                ],
+            ),
         )
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
-            default_namespace='mindsdb',
+            predictor_namespace="mindsdb",
+            default_namespace="mindsdb",
             steps=[
-                ApplyPredictorRowStep(
-                    namespace='mindsdb', predictor=Identifier('pred'),
-                    row_dict={'x1': 1, 'x2': '2'}
-                ),
+                ApplyPredictorRowStep(namespace="mindsdb", predictor=Identifier("pred"), row_dict={"x1": 1, "x2": "2"}),
             ],
         )
 
         plan = plan_query(
-            query, predictor_namespace='mindsdb', default_namespace='mindsdb', predictor_metadata={'pred': {}}
+            query, predictor_namespace="mindsdb", default_namespace="mindsdb", predictor_metadata={"pred": {}}
         )
 
         assert plan.steps == expected_plan.steps
 
     def test_select_from_predictor_get_columns(self):
-        sql = 'SELECT GDP_per_capita_USD FROM hdi_predictor_external WHERE 1 = 0'
+        sql = "SELECT GDP_per_capita_USD FROM hdi_predictor_external WHERE 1 = 0"
         query = parse_sql(sql)
 
         expected_query = Select(
-            targets=[Identifier('GDP_per_capita_USD')],
-            from_table=Identifier('hdi_predictor_external'),
-            where=BinaryOperation(
-                op="=",
-                args=[Constant(1), Constant(0)]
-            )
+            targets=[Identifier("GDP_per_capita_USD")],
+            from_table=Identifier("hdi_predictor_external"),
+            where=BinaryOperation(op="=", args=[Constant(1), Constant(0)]),
         )
         assert query.to_tree() == expected_query.to_tree()
 
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
-            default_namespace='mindsdb',
+            predictor_namespace="mindsdb",
+            default_namespace="mindsdb",
             steps=[
-                GetPredictorColumns(
-                    namespace='mindsdb',
-                    predictor=Identifier('hdi_predictor_external')
-                ),
-                ProjectStep(dataframe=Result(0), columns=[Identifier('GDP_per_capita_USD')]),
+                GetPredictorColumns(namespace="mindsdb", predictor=Identifier("hdi_predictor_external")),
+                ProjectStep(dataframe=Result(0), columns=[Identifier("GDP_per_capita_USD")]),
             ],
         )
 
         plan = plan_query(
-            query, predictor_namespace='mindsdb', default_namespace='mindsdb',
-            predictor_metadata={'hdi_predictor_external': {}}
+            query,
+            predictor_namespace="mindsdb",
+            default_namespace="mindsdb",
+            predictor_metadata={"hdi_predictor_external": {}},
         )
 
         assert plan.steps == expected_plan.steps
 
     def test_using_predictor_version(self):
         query = parse_sql(
-            '''
+            """
                         select * from mindsdb.pred.21
                         where x1 = 1
-                    '''
+                    """
         )
 
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
+            predictor_namespace="mindsdb",
             steps=[
                 ApplyPredictorRowStep(
-                    namespace='mindsdb', predictor=Identifier(parts=['pred', '21']),
-                    row_dict={'x1': 1}
+                    namespace="mindsdb", predictor=Identifier(parts=["pred", "21"]), row_dict={"x1": 1}
                 )
             ],
         )
 
-        plan = plan_query(query, predictor_metadata=[{'name': 'pred', 'integration_name': 'mindsdb'}])
+        plan = plan_query(query, predictor_metadata=[{"name": "pred", "integration_name": "mindsdb"}])
 
         assert plan.steps == expected_plan.steps
 
     def test_select_from_predictor_subselect(self):
         query = parse_sql(
-            '''
+            """
                         select * from mindsdb.pred.21
                         where x1 = (select id from int1.t1)
-                    '''
+                    """
         )
 
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
+            predictor_namespace="mindsdb",
             steps=[
                 FetchDataframeStep(
-                    integration='int1',
-                    query=parse_sql('select id as id from t1'),
+                    integration="int1",
+                    query=parse_sql("select id as id from t1"),
                 ),
                 ApplyPredictorRowStep(
-                    namespace='mindsdb',
-                    predictor=Identifier(parts=['pred', '21']),
-                    row_dict={'x1': Parameter(Result(0))}
-                )
+                    namespace="mindsdb",
+                    predictor=Identifier(parts=["pred", "21"]),
+                    row_dict={"x1": Parameter(Result(0))},
+                ),
             ],
         )
 
         plan = plan_query(
-            query,
-            integrations=['int1'],
-            predictor_metadata=[{'name': 'pred', 'integration_name': 'mindsdb'}]
+            query, integrations=["int1"], predictor_metadata=[{"name": "pred", "integration_name": "mindsdb"}]
         )
 
         assert plan.steps == expected_plan.steps
 
     def test_select_from_view_subselect(self):
         query = parse_sql(
-            '''
+            """
                         select * from v1
                         where x1 in (select id from int1.tab1)
-                    '''
+                    """
         )
 
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
+            predictor_namespace="mindsdb",
             steps=[
                 FetchDataframeStep(
-                    integration='int1',
-                    query=parse_sql('select id as id from tab1'),
+                    integration="int1",
+                    query=parse_sql("select id as id from tab1"),
                 ),
                 FetchDataframeStep(
-                    integration='mindsdb',
+                    integration="mindsdb",
                     query=Select(
                         targets=[Star()],
-                        from_table=Identifier('v1'),
-                        where=BinaryOperation(
-                            op='in',
-                            args=[
-                                Identifier(parts=['x1']),
-                                Parameter(Result(0))
-                            ]
-                        )
+                        from_table=Identifier("v1"),
+                        where=BinaryOperation(op="in", args=[Identifier(parts=["x1"]), Parameter(Result(0))]),
                     ),
                 ),
             ],
@@ -364,81 +354,66 @@ def test_select_from_view_subselect(self):
 
         plan = plan_query(
             query,
-            integrations=['int1'],
-            default_namespace='mindsdb',
-            predictor_metadata=[{'name': 'pred', 'integration_name': 'mindsdb'}]
+            integrations=["int1"],
+            default_namespace="mindsdb",
+            predictor_metadata=[{"name": "pred", "integration_name": "mindsdb"}],
         )
 
         assert plan.steps == expected_plan.steps
 
     def test_select_from_view_subselect_view(self):
         query = parse_sql(
-            '''
+            """
                         select * from v1
                         where x1 in (select v2.id from v2)
-                    '''
+                    """
         )
 
         expected_plan = QueryPlan(
-            predictor_namespace='mindsdb',
+            predictor_namespace="mindsdb",
             steps=[
                 FetchDataframeStep(
-                    integration='mindsdb',
-                    query=parse_sql('select v2.id as id from v2'),
+                    integration="mindsdb",
+                    query=parse_sql("select v2.id as id from v2"),
                 ),
                 FetchDataframeStep(
-                    integration='mindsdb',
+                    integration="mindsdb",
                     query=Select(
                         targets=[Star()],
-                        from_table=Identifier('v1'),
-                        where=BinaryOperation(
-                            op='in',
-                            args=[
-                                Identifier(parts=['x1']),
-                                Parameter(Result(0))
-                            ]
-                        )
+                        from_table=Identifier("v1"),
+                        where=BinaryOperation(op="in", args=[Identifier(parts=["x1"]), Parameter(Result(0))]),
                     ),
                 ),
             ],
         )
 
-        plan = plan_query(
-            query,
-            integrations=[],
-            default_namespace='mindsdb',
-            predictor_metadata=[]
-        )
+        plan = plan_query(query, integrations=[], default_namespace="mindsdb", predictor_metadata=[])
 
         assert plan.steps == expected_plan.steps
 
 
 class TestMLSelect:
-
     def test_select_from_predictor_plan_other_ml(self):
         # sends to integrations
-        query = parse_sql(''' select * from mlflow.predictors ''')
+        query = parse_sql(""" select * from mlflow.predictors """)
 
         expected_plan = QueryPlan(
-            steps=[
-                FetchDataframeStep(step_num=0, integration='mlflow', query=parse_sql('SELECT * FROM predictors'))
-            ],
+            steps=[FetchDataframeStep(step_num=0, integration="mlflow", query=parse_sql("SELECT * FROM predictors"))],
         )
 
-        plan = plan_query(query, predictor_metadata=[], integrations=['mlflow'])
+        plan = plan_query(query, predictor_metadata=[], integrations=["mlflow"])
 
         assert plan.steps == expected_plan.steps
 
 
 class TestNestedSelect:
-
     def test_using_predictor_in_subselect(self):
         """
         Use predictor in subselect when selecting from integration
         """
         sql = """
         SELECT *
-        FROM chromadb.test_tabl
+        FROM vectordb.test_tabl
         WHERE
             search_vector = (
                 SELECT emebddings
@@ -450,37 +425,25 @@ def test_using_predictor_in_subselect(self):
         ast_tree = parse_sql(sql)
         plan = plan_query(
             ast_tree,
-            integrations=['chromadb'],
-            predictor_metadata=[
-                {'name': 'embedding_model', 'integration_name': 'mindsdb'}
-            ]
+            integrations=["vectordb"],
+            predictor_metadata=[{"name": "embedding_model", "integration_name": "mindsdb"}],
         )
 
         expected_plan = [
             ApplyPredictorRowStep(
                 step_num=0,
-                namespace='mindsdb',
-                predictor=Identifier(parts=['embedding_model']),
-                row_dict={'content': 'some text'}
-            ),
-            ProjectStep(
-                step_num=1,
-                dataframe=Result(0),
-                columns=[Identifier(parts=['emebddings'])]
+                namespace="mindsdb",
+                predictor=Identifier(parts=["embedding_model"]),
+                row_dict={"content": "some text"},
             ),
+            ProjectStep(step_num=1, dataframe=Result(0), columns=[Identifier(parts=["emebddings"])]),
             FetchDataframeStep(
                 step_num=2,
-                integration='chromadb',
+                integration="vectordb",
                 query=Select(
                     targets=[Star()],
-                    from_table=Identifier(parts=['test_tabl']),
-                    where=BinaryOperation(
-                        op='=',
-                        args=[
-                            Identifier(parts=['search_vector']),
-                            Parameter(Result(1))
-                        ]
-                    )
+                    from_table=Identifier(parts=["test_tabl"]),
+                    where=BinaryOperation(op="=", args=[Identifier(parts=["search_vector"]), Parameter(Result(1))]),
                 ),
             ),
         ]
@@ -498,31 +461,27 @@ def test_using_integration_in_subselect(self):
         WHERE
             content = (
                 SELECT content
-                FROM chromadb.test_tabl
+                FROM vectordb.test_tabl
                 LIMIT 1
             )
         """
         ast_tree = parse_sql(sql)
         plan = plan_query(
             ast_tree,
-            integrations=['chromadb'],
-            predictor_metadata=[
-                {'name': 'embedding_model', 'integration_name': 'mindsdb'}
-            ]
+            integrations=["vectordb"],
+            predictor_metadata=[{"name": "embedding_model", "integration_name": "mindsdb"}],
         )
 
         expected_plan = [
             FetchDataframeStep(
-                step_num=0,
-                integration='chromadb',
-                query=parse_sql('SELECT content AS content FROM test_tabl LIMIT 1')
+                step_num=0, integration="vectordb", query=parse_sql("SELECT content AS content FROM test_tabl LIMIT 1")
             ),
             ApplyPredictorRowStep(
                 step_num=1,
-                namespace='mindsdb',
-                predictor=Identifier(parts=['embedding_model']),
-                row_dict={'content': Parameter(Result(0))}
-            )
+                namespace="mindsdb",
+                predictor=Identifier(parts=["embedding_model"]),
+                row_dict={"content": Parameter(Result(0))},
+            ),
         ]
 
         assert plan.steps == expected_plan
diff --git a/tests/unit/utilities/test_config.py b/tests/unit/utilities/test_config.py
index 88113161409..d5bd93d46b7 100644
--- a/tests/unit/utilities/test_config.py
+++ b/tests/unit/utilities/test_config.py
@@ -39,3 +39,23 @@ def test_invalid_mindsdb_db_con_raises_error(self):
                 error_message = str(exc_info.value)
                 assert "Invalid MINDSDB_DB_CON value" in error_message
                 assert invalid_db_con in error_message
+
+    def test_knowledge_bases_storage_env_does_not_override_storage_config(self):
+        Config._Config__instance = None
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_file = Path(tmpdir) / "config.json"
+            config_file.write_text(json.dumps({}))
+
+            with patch.dict(
+                os.environ,
+                {
+                    "MINDSDB_CONFIG_PATH": str(config_file),
+                    "MINDSDB_STORAGE_DIR": tmpdir,
+                    "KNOWLEDGE_BASES_STORAGE": "faiss, pgvector",
+                },
+                clear=False,
+            ):
+                cfg = Config()
+
+                assert cfg["knowledge_bases"]["storage"] is None
diff --git a/tests/unit/various/test_llm_utils.py b/tests/unit/various/test_llm_utils.py
index 28c7f41f960..d5df7a77e42 100644
--- a/tests/unit/various/test_llm_utils.py
+++ b/tests/unit/various/test_llm_utils.py
@@ -1,86 +1,12 @@
 import unittest
-from textwrap import dedent, indent
 
 from numpy import int64
 import pandas as pd
 
-from mindsdb.integrations.libs.llm.utils import ft_chat_formatter, ft_code_formatter, ft_cqa_formatter
-from mindsdb.integrations.libs.llm.utils import ft_jsonl_validation, ft_chat_format_validation
 from mindsdb.integrations.libs.llm.utils import get_completed_prompts
 
 
 class TestLLM(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        # used in `test_ft_chat_format_validation`
-        cls.valid_chats = [
-            # u/a pattern
-            [
-                {"role": "user", "content": "hi"},
-                {"role": "assistant", "content": "hello"},
-                {"role": "user", "content": "how are you?"},
-                {"role": "assistant", "content": "I'm good, thanks"},
-            ],
-            # u/a pattern
-            [
-                {"role": "user", "content": "hi"},
-                {"role": "assistant", "content": "hello"},
-                {"role": "user", "content": "how are you?"},
-            ],
-            # s/u/a pattern
-            [
-                {"role": "system", "content": "you are a useful assistant."},
-                {"role": "user", "content": "hello"},
-                {"role": "assistant", "content": "how are you?"},
-            ],
-            # s/u/a pattern
-            [
-                {"role": "system", "content": "you are a useful assistant."},
-                {"role": "user", "content": "hello"},
-                {"role": "assistant", "content": "how are you?"},
-                {"role": "user", "content": "I'm good, thanks"},
-            ],
-        ]
-
-        # used in `test_ft_chat_format_validation`
-        cls.invalid_chats = [
-            # invalid - repeated user
-            [
-                {"role": "user", "content": "hi"},
-                {"role": "user", "content": "hello"},  # this is invalid
-                {"role": "assistant", "content": "how are you?"},
-                {"role": "user", "content": "I'm good, thanks"},
-            ],
-            # invalid - repeated assistant
-            [
-                {"role": "user", "content": "hi"},
-                {"role": "assistant", "content": "hello"},
-                {"role": "assistant", "content": "how are you?"},  # this is invalid
-                {"role": "user", "content": "I'm good, thanks"},
-            ],
-            # invalid - incorrect system prompt order
-            [
-                {"role": "user", "content": "hi"},
-                {"role": "assistant", "content": "hello"},
-                {"role": "system", "content": "you are a useful assistant."},  # this is invalid
-                {"role": "user", "content": "I'm good, thanks"},
-            ],
-            # invalid roles
-            [
-                {"role": "user", "content": "hi"},
-                {"role": "invalid", "content": "this is an invalid role"},
-            ],
-            # invalid content
-            [
-                {"role": "user", "content": "hi"},
-                {"role": "assistant", "content": None},  # should always be a string
-            ],
-            # invalid - no assistant in the chat
-            [
-                {"role": "user", "content": "hi"},
-            ],
-        ]
-
     def test_get_completed_prompts(self):
         placeholder = "{{text}}"
         prefix = "You are a helpful assistant. Here is the user's input:"
@@ -107,160 +33,3 @@ def test_get_completed_prompts(self):
         df = pd.DataFrame({"text": user_inputs})
         with self.assertRaises(Exception):
             get_completed_prompts(base_template, df)
-
-    def test_ft_chat_format_validation(self):
-        for chat in self.valid_chats:
-            ft_chat_format_validation(chat)  # if chat is valid, returns `None`
-
-        for chat in self.invalid_chats:
-            with self.assertRaises(Exception):
-                ft_chat_format_validation(chat)  # all of these should raise an Exception
-
-    def test_ft_chat_formatter(self):
-        # 1a. long DF with required columns (`role` and `content`)
-        df = pd.DataFrame(
-            {
-                "role": ["system", "user", "assistant", "user"],
-                "content": ["you are a helpful assistant", "hello", "hi, how can I help?", "I'm good, thanks"],
-            }
-        )
-        chats = ft_chat_formatter(df)
-        assert list(chats[0].keys()) == ["messages"]
-        ft_chat_format_validation(chats[0]["messages"])  # valid, returns None
-
-        # 1b. add `chat_id` to df
-        df = pd.DataFrame(
-            {
-                "chat_id": [1, 1, 1, 2, 2, 2],
-                "role": ["system", "user", "assistant"] * 2,
-                "content": ["you are a helpful assistant", "hello", "hi, how can I help?"] * 2,
-            }
-        )
-        # add extra row at the end, belonging to first chat. This checks sorting.
-        df = pd.concat([df, pd.DataFrame({"chat_id": [1], "role": ["user"], "content": ["I'm good, thanks"]})])
-        chats = ft_chat_formatter(df)
-        for chat in chats:
-            assert list(chat.keys()) == ["messages"]
-            ft_chat_format_validation(chat["messages"])  # valid, returns None
-
-        # 1c. add `message_id` to df (scrambled to check sorting)
-        df = pd.DataFrame(
-            {
-                "chat_id": [1, 2, 1, 2, 1, 2],
-                "message_id": [1, 1, 2, 2, 3, 3],
-                "role": ["system", "system", "user", "user", "assistant", "assistant"],
-                "content": ["you are a helpful assistant"] * 2 + ["hello"] * 2 + ["hi, how can I help?"] * 2,
-            }
-        )
-        chats = ft_chat_formatter(df)
-        for chat in chats:
-            assert list(chat.keys()) == ["messages"]
-            ft_chat_format_validation(chat["messages"])  # valid, returns None
-
-        # 2a. json format - df contains single column `chat_json`
-        df = pd.DataFrame(
-            {
-                "chat_json": [
-                    '{"messages": [{"role": "user", "content": "hi"}, {"role": "assistant", "content": "hello"}]}'
-                ]
-            }
-        )
-        chats = ft_chat_formatter(df)
-        assert list(chats[0].keys()) == ["messages"]
-        ft_chat_format_validation(chats[0]["messages"])  # valid, returns None
-
-    def test_ft_jsonl_validation(self):
-        df = pd.DataFrame(
-            {
-                "role": ["system", "user", "assistant", "user"],
-                "content": ["you are a helpful assistant", "hello", "hi, how can I help?", "I'm good, thanks"],
-            }
-        )
-        chats = ft_chat_formatter(df)
-
-        # when validated, this method won't return anything
-        assert ft_jsonl_validation([line for line in chats]) is None
-
-        # otherwise, it raises an Exception
-        chats = ft_chat_formatter(df)
-        chats[0]["messages"][1]["role"] = "invalid"
-        with self.assertRaises(Exception):
-            ft_jsonl_validation([line for line in chats])
-
-    def test_ft_code_formatter(self):
-        df = pd.DataFrame(
-            {
-                "code": [
-                    "".join(
-                        [
-                            indent(
-                                dedent("""\
-                    # format chunks into prompts
-                    roles = []
-                    contents = []
-
-                    for idx in range(0, len(chunks), 3):
-                    """),
-                                " " * 4 * 2,
-                            ),  # mind the base indent level
-                            indent(
-                                dedent(
-                                    """pre, mid, suf = chunks[idx:idx+3]
-
-                    interleaved = list(itertools.chain(*zip(templates, (pre, mid, suf))))
-                    """
-                                ),
-                                " " * 4 * 3,
-                            ),  # mind the base indent level
-                        ]
-                    )
-                ]
-            }
-        )
-        df2 = ft_code_formatter(df, chunk_size=110)
-
-        assert list(df2["role"]) == ["system", "user", "assistant"]
-        assert (
-            df2["content"].iloc[0]
-            == "You are a powerful text to code model. Your job is to provide great code completions. As context, you are given code that is found immediately before and after the code you must generate.\n\nYou must output the code that should go in between the prefix and suffix.\n\n"
-        )  # noqa
-        assert (
-            df2["content"].iloc[1]
-            == "### Code prefix:\n        # format chunks into prompts\n        roles = []\n        contents = []\n\n\n### Code suffix:\n                                interleaved = list(itertools.chain(*zip(templates, (pre, mid, suf))))\n\n### Completion:"
-        )  # noqa
-        assert (
-            df2["content"].iloc[2]
-            == "        for idx in range(0, len(chunks), 3):\n            pre, mid, suf = chunks[idx:idx+3]\n\n"
-        )  # noqa
-
-        df2 = ft_code_formatter(df, format="fim", chunk_size=110)
-        assert list(df2["role"]) == ["system", "user", "assistant"]
-        assert (
-            df2["content"].iloc[0]
-            == "You are a powerful text to code model. Your job is to provide great code completions. As context, you are given code that is found immediately before and after the code you must generate.\n\nYou must output the code that should go in between the prefix and suffix.\n\n"
-        )  # noqa
-        assert (
-            df2["content"].iloc[1]
-            == "<PRE>\n        # format chunks into prompts\n        roles = []\n        contents = []\n\n\n<SUF>\n                                interleaved = list(itertools.chain(*zip(templates, (pre, mid, suf))))\n\n<MID>"
-        )  # noqa
-        assert (
-            df2["content"].iloc[2]
-            == "        for idx in range(0, len(chunks), 3):\n            pre, mid, suf = chunks[idx:idx+3]\n\n"
-        )  # noqa
-
-    def test_ft_cqa_formatter(self):
-        df = pd.DataFrame(
-            {
-                "instruction": ["Answer accurately."],
-                "context": ["You are a helpful assistant."],
-                "question": ["What is the capital of France?"],
-                "answer": ["Paris"],
-            }
-        )
-
-        df2 = ft_cqa_formatter(df)
-
-        assert list(df2["role"]) == ["system", "user", "assistant"]
-        assert df2["content"].iloc[0] == "Answer accurately.\nYou are a helpful assistant."
-        assert df2["content"].iloc[1] == "What is the capital of France?"
-        assert df2["content"].iloc[2] == "Paris"
diff --git a/tests/unit/various/test_main.py b/tests/unit/various/test_main.py
new file mode 100644
index 00000000000..689a9eb93af
--- /dev/null
+++ b/tests/unit/various/test_main.py
@@ -0,0 +1,183 @@
+import pathlib
+import shutil
+from unittest.mock import patch
+import pytest
+
+
+class TestMainCleanup:
+    @pytest.fixture
+    def patch_main_config(self, tmp_path, monkeypatch):
+        import mindsdb.__main__ as main_mod
+
+        monkeypatch.setattr(main_mod, "config", {"paths": {"tmp": tmp_path}})
+        return tmp_path, main_mod
+
+    @pytest.fixture
+    def errors(self, caplog):
+        """Capture only ERROR logs as concatenated text"""
+
+        class ErrorCapture:
+            @property
+            def text(self):
+                return "\n".join(r.getMessage() for r in caplog.records if r.levelname == "ERROR")
+
+        caplog.clear()
+        caplog.set_level("ERROR")
+        return ErrorCapture()
+
+    def test_cleans_files_and_dirs_but_keeps_tmp_path(self, patch_main_config):
+        tmp_path, main_mod = patch_main_config
+        (tmp_path / "a.txt").write_text("hello")
+        sub = tmp_path / "sub"
+        sub.mkdir()
+        (sub / "b.txt").write_text("world")
+
+        main_mod.clean_mindsdb_tmp_dir()
+
+        assert tmp_path.exists(), "tmp_path itself should not be deleted"
+        assert list(tmp_path.iterdir()) == [], "All content should be removed"
+
+    def test_empty_directory(self, patch_main_config):
+        tmp_path, main_mod = patch_main_config
+        main_mod.clean_mindsdb_tmp_dir()
+        assert tmp_path.exists()
+        assert list(tmp_path.iterdir()) == []
+
+    def test_deeply_nested_directories(self, patch_main_config):
+        tmp_path, main_mod = patch_main_config
+        deep = tmp_path / "a" / "b" / "c" / "d"
+        deep.mkdir(parents=True)
+        (deep / "file.txt").write_text("deep")
+
+        main_mod.clean_mindsdb_tmp_dir()
+
+        assert tmp_path.exists()
+        assert not (tmp_path / "a").exists()
+
+    def test_symlinks_are_handled(self, patch_main_config):
+        tmp_path, main_mod = patch_main_config
+
+        external_file = tmp_path.parent / "external.txt"
+        external_file.write_text("external")
+
+        (tmp_path / "link_to_external").symlink_to(external_file)
+
+        main_mod.clean_mindsdb_tmp_dir()
+
+        assert tmp_path.exists()
+        assert list(tmp_path.iterdir()) == []
+        assert external_file.exists()
+
+        external_file.unlink()
+
+    def test_unlink_failure_continues_and_logs(self, patch_main_config, errors):
+        tmp_path, main_mod = patch_main_config
+        (tmp_path / "ok1.txt").write_text("a")
+        (tmp_path / "failing_file.txt").write_text("b")
+        (tmp_path / "ok2.txt").write_text("c")
+
+        original_unlink = pathlib.Path.unlink
+
+        def mock_unlink(self, *args, **kwargs):
+            if self.name == "failing_file.txt":
+                raise PermissionError("Cannot delete file")
+            return original_unlink(self, *args, **kwargs)
+
+        with patch.object(pathlib.Path, "unlink", mock_unlink):
+            main_mod.clean_mindsdb_tmp_dir()
+
+        txt = errors.text
+        assert "Failed to clean" in txt
+        assert "Cannot delete file" in txt
+
+        assert not (tmp_path / "ok1.txt").exists()
+        assert not (tmp_path / "ok2.txt").exists()
+        assert (tmp_path / "failing_file.txt").exists()
+
+    def test_rmtree_failure_continues_and_logs(self, patch_main_config, errors):
+        tmp_path, main_mod = patch_main_config
+
+        (tmp_path / "file.txt").write_text("content")
+        (tmp_path / "failing_dir").mkdir()
+        (tmp_path / "another_file.txt").write_text("more content")
+        (tmp_path / "good_dir").mkdir()
+
+        original_rmtree = shutil.rmtree
+
+        def mock_rmtree(path, *args, **kwargs):
+            if "failing_dir" in str(path):
+                raise PermissionError("Cannot delete directory")
+            return original_rmtree(path, *args, **kwargs)
+
+        with patch("shutil.rmtree", mock_rmtree):
+            main_mod.clean_mindsdb_tmp_dir()
+
+        txt = errors.text
+        assert "Failed to clean" in txt
+        assert "Cannot delete directory" in txt
+
+        assert not (tmp_path / "file.txt").exists()
+        assert not (tmp_path / "another_file.txt").exists()
+        assert not (tmp_path / "good_dir").exists()
+        assert (tmp_path / "failing_dir").exists()
+
+    def test_mixed_failures_continue_cleanup(self, patch_main_config, errors):
+        tmp_path, main_mod = patch_main_config
+
+        (tmp_path / "good_file1.txt").write_text("a")
+        (tmp_path / "failing_file.txt").write_text("b")
+        (tmp_path / "good_file2.txt").write_text("c")
+        (tmp_path / "failing_dir").mkdir()
+        (tmp_path / "good_dir").mkdir()
+
+        original_unlink = pathlib.Path.unlink
+        original_rmtree = shutil.rmtree
+
+        def mock_unlink(self, *args, **kwargs):
+            if self.name == "failing_file.txt":
+                raise PermissionError("Cannot delete file")
+            return original_unlink(self, *args, **kwargs)
+
+        def mock_rmtree(path, *args, **kwargs):
+            if "failing_dir" in str(path):
+                raise PermissionError("Cannot delete directory")
+            return original_rmtree(path, *args, **kwargs)
+
+        with patch.object(pathlib.Path, "unlink", mock_unlink), patch("shutil.rmtree", mock_rmtree):
+            main_mod.clean_mindsdb_tmp_dir()
+
+        txt = errors.text
+        # We should have at least two "Failed to clean" lines (file + dir)
+        assert txt.count("Failed to clean") >= 2
+
+        assert not (tmp_path / "good_file1.txt").exists()
+        assert not (tmp_path / "good_file2.txt").exists()
+        assert not (tmp_path / "good_dir").exists()
+        assert (tmp_path / "failing_file.txt").exists()
+        assert (tmp_path / "failing_dir").exists()
+
+    def test_nonexistent_tmp_path(self, monkeypatch):
+        import mindsdb.__main__ as main_mod
+        from pathlib import Path
+
+        nonexistent = Path("/tmp/nonexistent_mindsdb_test_dir_12345")
+        assert not nonexistent.exists()
+
+        monkeypatch.setattr(main_mod, "config", {"paths": {"tmp": nonexistent}})
+        main_mod.clean_mindsdb_tmp_dir()
+        assert not nonexistent.exists()
+
+    def test_logger_called_with_correct_level(self, patch_main_config):
+        tmp_path, main_mod = patch_main_config
+        (tmp_path / "failing_file.txt").write_text("content")
+
+        original_unlink = pathlib.Path.unlink
+
+        def mock_unlink(self, *args, **kwargs):
+            if self.name == "failing_file.txt":
+                raise PermissionError("Test error")
+            return original_unlink(self, *args, **kwargs)
+
+        with patch.object(pathlib.Path, "unlink", mock_unlink), patch("mindsdb.__main__.logger") as mock_logger:
+            main_mod.clean_mindsdb_tmp_dir()
+            assert mock_logger.error.called or mock_logger.exception.called
diff --git a/tests/unit/various/test_rag_config_loader.py b/tests/unit/various/test_rag_config_loader.py
deleted file mode 100644
index fc555a553ff..00000000000
--- a/tests/unit/various/test_rag_config_loader.py
+++ /dev/null
@@ -1,108 +0,0 @@
-from unittest.mock import Mock
-from mindsdb.integrations.utilities.rag.settings import (
-    RetrieverType,
-    MultiVectorRetrieverMode,
-    SearchType,
-    RAGPipelineModel,
-)
-from mindsdb.integrations.utilities.rag.config_loader import load_rag_config
-
-
-def test_load_rag_config_empty():
-    """Test loading RAG config with empty parameters"""
-    config = load_rag_config({})
-    assert isinstance(config, RAGPipelineModel)
-
-
-def test_load_rag_config_basic():
-    """Test loading RAG config with basic parameters"""
-    base_config = {"retriever_type": RetrieverType.VECTOR_STORE.value, "search_type": SearchType.SIMILARITY.value}
-    config = load_rag_config(base_config)
-
-    assert isinstance(config, RAGPipelineModel)
-    assert config.retriever_type == RetrieverType.VECTOR_STORE
-    assert config.search_type == SearchType.SIMILARITY
-
-
-def test_load_rag_config_with_search_kwargs():
-    """Test loading RAG config with search kwargs"""
-    base_config = {
-        "retriever_type": RetrieverType.VECTOR_STORE.value,
-        "search_type": SearchType.SIMILARITY.value,
-        "search_kwargs": {"k": 5},
-    }
-    config = load_rag_config(base_config)
-
-    assert isinstance(config, RAGPipelineModel)
-    assert config.search_kwargs.k == 5
-
-
-def test_load_rag_config_with_embedding_model():
-    """Test loading RAG config with embedding model"""
-    base_config = {"retriever_type": RetrieverType.VECTOR_STORE.value, "search_type": SearchType.SIMILARITY.value}
-
-    # Create a mock that's a subclass of Embeddings
-    class MockEmbeddings:
-        def embed_documents(self, texts):
-            return [[0.0] * 10] * len(texts)
-
-        def embed_query(self, text):
-            return [0.0] * 10
-
-    embedding_model = MockEmbeddings()
-    config = load_rag_config(base_config, embedding_model=embedding_model)
-
-    assert isinstance(config, RAGPipelineModel)
-    assert config.embedding_model == embedding_model
-
-
-def test_load_rag_config_with_multi_vector_mode():
-    """Test loading RAG config with multi vector mode"""
-    base_config = {
-        "retriever_type": RetrieverType.VECTOR_STORE.value,
-        "search_type": SearchType.SIMILARITY.value,
-        "multi_retriever_mode": MultiVectorRetrieverMode.SPLIT.value,  # Use correct enum value
-    }
-    config = load_rag_config(base_config)
-
-    assert isinstance(config, RAGPipelineModel)
-    assert config.retriever_type == RetrieverType.VECTOR_STORE
-    assert config.search_type == SearchType.SIMILARITY
-    assert config.multi_retriever_mode == MultiVectorRetrieverMode.SPLIT
-
-
-def test_load_rag_config_with_kb_params():
-    """Test loading RAG config with knowledge base parameters"""
-    base_config = {"retriever_type": RetrieverType.VECTOR_STORE.value, "search_type": SearchType.SIMILARITY.value}
-    kb_params = {"search_kwargs": {"k": 5}}
-    config = load_rag_config(base_config, kb_params)
-
-    assert isinstance(config, RAGPipelineModel)
-    assert config.search_kwargs.k == 5
-
-
-def test_load_rag_config_with_vector_store_config():
-    """Test loading RAG config with vector store config"""
-    base_config = {"retriever_type": RetrieverType.VECTOR_STORE.value, "search_type": SearchType.SIMILARITY.value}
-    kb_params = {"vector_store_config": {"kb_table": Mock()}}
-    config = load_rag_config(base_config, kb_params)
-
-    assert isinstance(config, RAGPipelineModel)
-    assert config.vector_store_config.kb_table == kb_params["vector_store_config"]["kb_table"]
-
-
-def test_load_rag_config_from_knowledge_base():
-    """Test RAG config loading in knowledge base context"""
-    base_config = {
-        "retriever_type": RetrieverType.VECTOR_STORE.value,
-        "search_type": SearchType.SIMILARITY.value,
-        "search_kwargs": {"k": 5},
-    }
-    kb_params = {"vector_store_config": {"kb_table": Mock()}}
-    config = load_rag_config(base_config, kb_params)
-
-    assert isinstance(config, RAGPipelineModel)
-    assert config.retriever_type == RetrieverType.VECTOR_STORE
-    assert config.search_type == SearchType.SIMILARITY
-    assert config.search_kwargs.k == 5
-    assert config.vector_store_config.kb_table == kb_params["vector_store_config"]["kb_table"]
diff --git a/tests/unit/various/test_retrieval_tool.py b/tests/unit/various/test_retrieval_tool.py
deleted file mode 100644
index 93f4b3c3296..00000000000
--- a/tests/unit/various/test_retrieval_tool.py
+++ /dev/null
@@ -1,84 +0,0 @@
-import pytest
-from unittest.mock import Mock
-from mindsdb.integrations.utilities.rag.settings import (
-    RetrieverType,
-    MultiVectorRetrieverMode,
-    VectorStoreConfig,
-    DEFAULT_LLM_MODEL,
-    DEFAULT_TEST_TABLE_NAME,
-    DEFAULT_CHUNK_SIZE,
-)
-from mindsdb.integrations.utilities.rag.config_loader import load_rag_config
-
-
-@pytest.fixture
-def mock_tools_config():
-    return {
-        "retriever_type": "vector_store",
-        "multi_retriever_mode": "both",
-        "embedding_model": Mock(),
-        "documents": [Mock()],
-        "vector_store_config": {"vector_store_type": "chromadb", "collection_name": "test"},
-        "invalid_param": "should_be_filtered_out",
-    }
-
-
-def test_rag_params_conversion():
-    """Test that parameters are correctly converted to RAGPipelineModel"""
-    tools_config = {
-        "retriever_type": "vector_store",
-        "multi_retriever_mode": "both",
-    }
-    rag_config = load_rag_config(tools_config)
-    assert rag_config.retriever_type == RetrieverType.VECTOR_STORE
-    assert rag_config.multi_retriever_mode == MultiVectorRetrieverMode.BOTH
-
-
-def test_invalid_params():
-    """Test that invalid enum values raise appropriate errors"""
-    tools_config = {
-        "retriever_type": "invalid_type",
-    }
-    with pytest.raises(ValueError):
-        load_rag_config(tools_config)
-
-    tools_config = {"invalid_param": "invalid_type"}
-    with pytest.raises(ValueError):
-        load_rag_config(tools_config)
-
-
-def test_vector_store_config_conversion():
-    """Test that vector store config is properly handled"""
-    tools_config = {"vector_store_config": {"vector_store_type": "chromadb", "collection_name": "test"}}
-    rag_config = load_rag_config(tools_config)
-    assert isinstance(rag_config.vector_store_config, VectorStoreConfig)
-    assert rag_config.vector_store_config.collection_name == "test"
-
-
-def test_default_values():
-    """Test that default values are properly set"""
-    tools_config = {}
-    rag_config = load_rag_config(tools_config)
-    # Test default enum values
-    assert rag_config.retriever_type == RetrieverType.VECTOR_STORE
-    assert rag_config.multi_retriever_mode == MultiVectorRetrieverMode.BOTH
-    # Test other default values
-    assert rag_config.llm_model_name == DEFAULT_LLM_MODEL
-    assert rag_config.table_name == DEFAULT_TEST_TABLE_NAME
-    assert rag_config.chunk_size == DEFAULT_CHUNK_SIZE
-    assert isinstance(rag_config.vector_store_config, VectorStoreConfig)
-
-
-@pytest.mark.parametrize(
-    "field,value,expected",
-    [
-        ("retriever_type", "auto", RetrieverType.AUTO),
-        ("multi_retriever_mode", "split", MultiVectorRetrieverMode.SPLIT),
-        ("chunk_size", 500, 500),
-    ],
-)
-def test_field_assignments(field, value, expected):
-    """Test various field assignments"""
-    tools_config = {field: value}
-    rag_config = load_rag_config(tools_config)
-    assert getattr(rag_config, field) == expected
diff --git a/tests/unused/integration/knowledge_bases/mindsdb_langchain_pgvector_integration_test.py b/tests/unused/integration/knowledge_bases/mindsdb_langchain_pgvector_integration_test.py
deleted file mode 100644
index 3a16dac44d0..00000000000
--- a/tests/unused/integration/knowledge_bases/mindsdb_langchain_pgvector_integration_test.py
+++ /dev/null
@@ -1,64 +0,0 @@
-from mindsdb.integrations.utilities.rag.loaders.vector_store_loader.pgvector import PGVectorMDB
-from mindsdb.integrations.handlers.langchain_embedding_handler.fastapi_embeddings import FastAPIEmbeddings
-
-
-def setup_pgvector_database():
-    """Setup pgvector database"""
-    # Using port 15432 to avoid conflicts with local PostgreSQL
-    connection_string = "postgresql://gateway:gateway@localhost:15432/gateway"
-
-    print(f"Connecting to: {connection_string}")
-
-    # Initialize FastAPI embeddings
-    embeddings = FastAPIEmbeddings(
-        api_base="http://localhost:8043/v1/embeddings",
-        model="sparse_model"
-    )
-
-    # Initialize PGVectorMDB
-    vector_db = PGVectorMDB(
-        connection_string=connection_string,
-        collection_name="test_dev_doc_vectors",
-        embedding_function=embeddings,
-        is_sparse=True,  # Using sparse vectors
-        vector_size=30522  # Size for sparse vectors
-    )
-
-    return vector_db
-
-
-def test_vector_queries(vector_db):
-    """Test various vector queries"""
-    print("\nTesting vector queries...")
-
-    # Test text to be embedded
-    test_text = "For the Bsecondaryl containment"
-
-    # Get embeddings for the test text
-    embedding = vector_db.embedding_function.embed_query(test_text)
-
-    # Query similar vectors
-    results = vector_db._query_collection(
-        embedding=embedding,
-        k=5
-    )
-
-    print("\nVector similarity search results:")
-    for item, distance in results:
-        print(f"Content: {item.content}")
-        print(f"Metadata: {item.metadata}")
-        print(f"Distance: {distance}")
-        print("---")
-
-
-def main():
-    # Setup vector database
-    print("\nSetting up pgvector database...")
-    vector_db = setup_pgvector_database()
-
-    # Run tests
-    test_vector_queries(vector_db)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/tests/unused/integration/rag/test_rag_search_kwargs.py b/tests/unused/integration/rag/test_rag_search_kwargs.py
deleted file mode 100644
index 7ee668790fd..00000000000
--- a/tests/unused/integration/rag/test_rag_search_kwargs.py
+++ /dev/null
@@ -1,271 +0,0 @@
-import os
-import uuid
-import pytest
-from unittest.mock import Mock, patch
-from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-from langchain_core.documents import Document
-from langchain.vectorstores.base import VectorStore
-import tempfile
-import shutil
-from langchain_community.vectorstores import Chroma
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-
-from mindsdb.integrations.utilities.rag.settings import (
-    RAGPipelineModel,
-    RetrieverType,
-    SearchKwargs,
-    SearchType,
-    MultiVectorRetrieverMode,
-    DEFAULT_LLM_MODEL,
-    DEFAULT_LLM_ENDPOINT
-)
-from mindsdb.integrations.utilities.rag.pipelines.rag import LangChainRAGPipeline
-
-requires_openai = pytest.mark.skipif(
-    not os.getenv("OPENAI_API_KEY"),
-    reason="OPENAI_API_KEY environment variable not set"
-)
-
-
-@pytest.fixture
-def chat_llm():
-    api_key = os.getenv("OPENAI_API_KEY")
-    if not api_key:
-        pytest.skip("OPENAI_API_KEY environment variable not set")
-    return ChatOpenAI(
-        model=DEFAULT_LLM_MODEL,
-        openai_api_base=DEFAULT_LLM_ENDPOINT,
-        api_key=api_key
-    )
-
-
-@pytest.fixture
-def embeddings():
-    api_key = os.getenv("OPENAI_API_KEY")
-    if not api_key:
-        pytest.skip("OPENAI_API_KEY environment variable not set")
-    return OpenAIEmbeddings(api_key=api_key)
-
-
-class MockVectorStore(VectorStore):
-    def add_texts(self, *args, **kwargs):
-        pass
-
-    def similarity_search(self, *args, **kwargs):
-        pass
-
-    def as_retriever(self, **kwargs):
-        return Mock()
-
-
-@pytest.fixture
-def sample_documents():
-    return [
-        Document(page_content="Test document 1", metadata={"source": "test1"}),
-        Document(page_content="Test document 2", metadata={"source": "test2"})
-    ]
-
-
-@pytest.fixture
-def vector_store_path():
-    temp_dir = tempfile.mkdtemp()
-    yield temp_dir
-    shutil.rmtree(temp_dir)
-
-
-@pytest.fixture
-def vector_store(embeddings, vector_store_path):
-    return Chroma(
-        embedding_function=embeddings,
-        persist_directory=vector_store_path
-    )
-
-
-@pytest.fixture
-def base_config(sample_documents, chat_llm, embeddings, vector_store):
-    return RAGPipelineModel(
-        documents=sample_documents,
-        vector_store=vector_store,
-        embedding_model=embeddings,
-        llm=chat_llm
-    )
-
-
-class TestRAGSearchKwargs:
-    @pytest.fixture(autouse=True)
-    def setup(self, base_config, sample_documents, chat_llm, embeddings, vector_store):
-        """Setup test configuration with fixtures"""
-        self.base_config = base_config
-        self.sample_documents = sample_documents
-        self.chat_llm = chat_llm
-        self.embeddings = embeddings
-        self.vector_store = vector_store
-        self.base_dict = {
-            'documents': self.sample_documents,
-            'vector_store': self.vector_store,
-            'embedding_model': self.embeddings,
-            'llm': self.chat_llm
-        }
-
-    @requires_openai
-    def test_vector_store_retriever_search_kwargs(self):
-        config = RAGPipelineModel(
-            **self.base_dict,
-            search_type=SearchType.SIMILARITY_SCORE_THRESHOLD,
-            search_kwargs=SearchKwargs(
-                k=3,
-                score_threshold=0.5
-            ),
-            retriever_type=RetrieverType.VECTOR_STORE
-        )
-        mock_retriever = Mock()
-        mock_retriever.search_kwargs = {"k": 3, "score_threshold": 0.5}
-        with patch('mindsdb.integrations.utilities.rag.vector_store.VectorStoreOperator') as mock_vs_op:
-            mock_vs_op.return_value.vector_store.as_retriever.return_value = mock_retriever
-            _ = LangChainRAGPipeline.from_retriever(config)
-            assert mock_retriever.search_kwargs == {"k": 3, "score_threshold": 0.5}
-
-    def test_auto_retriever_search_kwargs(self):
-        config = RAGPipelineModel(
-            **self.base_dict,
-            search_type=SearchType.MMR,
-            search_kwargs=SearchKwargs(
-                k=2,
-                fetch_k=4,
-                lambda_mult=0.7
-            ),
-            retriever_type=RetrieverType.AUTO
-        )
-        mock_retriever = Mock()
-        mock_retriever.search_kwargs = {"k": 2, "fetch_k": 4, "lambda_mult": 0.7}
-        mock_llm_response = Mock()
-        mock_llm_response.content = '[{"name": "source", "description": "Source field", "type": "string"}]'
-        with patch('mindsdb.integrations.utilities.rag.retrievers.auto_retriever.AutoRetriever') as MockAutoRetriever, \
-             patch('langchain_openai.chat_models.ChatOpenAI.invoke', return_value=mock_llm_response):
-            mock_auto = Mock()
-            mock_auto.as_runnable.return_value = mock_retriever
-            MockAutoRetriever.return_value = mock_auto
-            _ = LangChainRAGPipeline.from_auto_retriever(config)
-            assert mock_retriever.search_kwargs == {"k": 2, "fetch_k": 4, "lambda_mult": 0.7}
-
-    def test_search_kwargs_validation(self):
-        """Test the validation rules for SearchKwargs"""
-        # Test fetch_k validation for MMR search type
-        with pytest.raises(ValueError, match="fetch_k must be greater than k"):
-            RAGPipelineModel(
-                **self.base_dict,
-                search_type=SearchType.MMR,
-                search_kwargs=SearchKwargs(
-                    k=5,
-                    fetch_k=3,
-                    lambda_mult=0.7
-                )
-            )
-
-        # Test MMR parameter requirements
-        with pytest.raises(ValueError, match="lambda_mult is required when using fetch_k"):
-            RAGPipelineModel(
-                **self.base_dict,
-                search_type=SearchType.MMR,
-                search_kwargs=SearchKwargs(
-                    k=3,
-                    fetch_k=5
-                )
-            )
-
-        with pytest.raises(ValueError, match="fetch_k is required when using lambda_mult"):
-            RAGPipelineModel(
-                **self.base_dict,
-                search_type=SearchType.MMR,
-                search_kwargs=SearchKwargs(
-                    k=3,
-                    lambda_mult=0.7
-                )
-            )
-
-        # Test score_threshold requirement for SIMILARITY_SCORE_THRESHOLD
-        with pytest.raises(ValueError, match="score_threshold is required"):
-            RAGPipelineModel(
-                **self.base_dict,
-                search_type=SearchType.SIMILARITY_SCORE_THRESHOLD,
-                search_kwargs=SearchKwargs(
-                    k=3
-                )
-            )
-
-    def test_search_type_compatibility(self):
-        """Test that search kwargs match the search type"""
-        # Test MMR search configuration
-        config = RAGPipelineModel(
-            **self.base_dict,
-            search_type=SearchType.MMR,
-            search_kwargs=SearchKwargs(
-                k=3,
-                fetch_k=6,
-                lambda_mult=0.7
-            )
-        )
-        assert config.search_kwargs.fetch_k == 6
-        assert config.search_kwargs.lambda_mult == 0.7
-
-        # Test similarity_score_threshold configuration
-        config = RAGPipelineModel(
-            **self.base_dict,
-            search_type=SearchType.SIMILARITY_SCORE_THRESHOLD,
-            search_kwargs=SearchKwargs(
-                k=3,
-                score_threshold=0.5
-            )
-        )
-        assert config.search_kwargs.score_threshold == 0.5
-
-        # Test basic similarity configuration
-        config = RAGPipelineModel(
-            **self.base_dict,
-            search_type=SearchType.SIMILARITY,
-            search_kwargs=SearchKwargs(
-                k=3,
-                filter={"source": "test1"}
-            )
-        )
-        assert config.search_kwargs.filter == {"source": "test1"}
-
-    def test_multi_vector_retriever_search_kwargs(self):
-        """Test search kwargs for multi vector retriever"""
-        config = RAGPipelineModel(
-            **self.base_dict,
-            search_type=SearchType.SIMILARITY,
-            search_kwargs=SearchKwargs(
-                k=5,
-                filter={"source": "test1"}
-            ),
-            retriever_type=RetrieverType.MULTI,
-            multi_retriever_mode=MultiVectorRetrieverMode.BOTH
-        )
-
-        mock_retriever = Mock()
-        mock_retriever.search_kwargs = {"k": 5, "filter": {"source": "test1"}}
-
-        with patch('mindsdb.integrations.utilities.rag.pipelines.rag.MultiVectorRetriever') as MockMultiRetrieverClass:
-            class MockMultiRetriever:
-                def __init__(self, config):
-                    self.text_splitter = RecursiveCharacterTextSplitter(
-                        chunk_size=config.chunk_size,
-                        chunk_overlap=config.chunk_overlap
-                    )
-                    self.documents = config.documents
-                    self.config = config
-
-                def as_runnable(self):
-                    return mock_retriever
-
-                def _split_documents(self):
-                    return [], []
-
-                def _generate_id_and_split_document(self, doc):
-                    return str(uuid.uuid4()), [doc]
-
-            MockMultiRetrieverClass.side_effect = MockMultiRetriever
-
-            _ = LangChainRAGPipeline.from_multi_vector_retriever(config)
-            assert mock_retriever.search_kwargs == {"k": 5, "filter": {"source": "test1"}}
diff --git a/tests/unused/integrations/utilities/rag/rerankers/test_openai_reranker.py b/tests/unused/integrations/utilities/rag/rerankers/test_openai_reranker.py
deleted file mode 100644
index 7b0c5cafa91..00000000000
--- a/tests/unused/integrations/utilities/rag/rerankers/test_openai_reranker.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from langchain.schema import Document
-import pytest
-
-from mindsdb.integrations.utilities.rag.rerankers.reranker_compressor import LLMReranker
-from mindsdb.integrations.utilities.rag.settings import RerankerConfig
-
-
-@pytest.mark.asyncio
-async def test_openai_reranker():
-    openai_reranker = LLMReranker()
-    results = await openai_reranker.compress_documents(
-        documents=[Document(page_content="Jack declared that he likes cats more than dogs"),
-                   Document(page_content="Jack declared that he likes AI")],
-        query="Jack's opinion on animals",
-    )
-    assert len(results) == 1
-    assert "cats" in results[0].page_content
-
-
-@pytest.mark.asyncio
-async def test_openai_reranker_diff_threshold():
-    openai_reranker = LLMReranker(filtering_threshold=0.6)
-    assert openai_reranker.filtering_threshold == 0.6
-    results = await openai_reranker.compress_documents(
-        documents=[Document(page_content="Jack declared that he likes cats more than dogs"),
-                   Document(page_content="Jack declared that he likes AI")],
-        query="Jack's opinion on animals",
-    )
-    assert len(results) == 1
-    assert "cats" in results[0].page_content
-    assert openai_reranker.filtering_threshold == 0.6
-
-
-@pytest.mark.asyncio
-async def test_openai_reranker_config():
-    config = RerankerConfig(filtering_threshold=0.6, model="gpt-3.5-turbo", base_url="https://api.openai.com/v1")
-    openai_reranker = LLMReranker(filtering_threshold=config.filtering_threshold, model=config.model,
-                                  base_url=config.base_url)
-    assert openai_reranker.filtering_threshold == 0.6
-    results = await openai_reranker.compress_documents(
-        documents=[Document(page_content="Jack declared that he likes cats more than dogs"),
-                   Document(page_content="Jack declared that he likes AI")],
-        query="Jack's opinion on animals",
-    )
-    assert len(results) == 1
-    assert "cats" in results[0].page_content
-    assert openai_reranker.filtering_threshold == 0.6
diff --git a/tests/unused/integrations/utilities/rag/retrievers/test_multi_hop_retriever.py b/tests/unused/integrations/utilities/rag/retrievers/test_multi_hop_retriever.py
deleted file mode 100644
index 9cbb199f966..00000000000
--- a/tests/unused/integrations/utilities/rag/retrievers/test_multi_hop_retriever.py
+++ /dev/null
@@ -1,127 +0,0 @@
-from typing import List, Any, Optional
-
-import pytest
-from langchain_core.documents import Document
-from langchain_core.retrievers import BaseRetriever
-from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import BaseMessage
-
-from mindsdb.integrations.utilities.rag.retrievers import MultiHopRetriever
-
-
-# Simple template for testing
-TEST_TEMPLATE = """Question: {question}
-Context: {context}
-Generate follow-up questions:"""
-
-
-class MockRetriever(BaseRetriever):
-    """Simple mock retriever that returns predefined documents"""
-    def _get_relevant_documents(self, query: str, **kwargs) -> List[Document]:
-        if "Wright brothers" in query:
-            return [Document(page_content="The Wright brothers invented the airplane.")]
-        if "World War 1" in query:
-            return [Document(page_content="Airplanes were used extensively in WWI.")]
-        return []
-
-
-class MockLLM(BaseChatModel):
-    """Simple mock LLM that returns predefined responses"""
-    @property
-    def _llm_type(self) -> str:
-        return "mock"
-
-    def _generate(self, messages: List[BaseMessage], stop: Optional[List[str]] = None, run_manager: Optional[Any] = None, **kwargs) -> Any:
-        raise NotImplementedError("Not needed for tests")
-
-    def invoke(self, input_str: str, **kwargs) -> str:
-        if "Wright brothers" in str(input_str):
-            return '["How were airplanes used in World War 1?"]'
-        return "[]"
-
-
-class InvalidOutputLLM(BaseChatModel):
-    """Mock LLM that always returns invalid JSON"""
-    @property
-    def _llm_type(self) -> str:
-        return "mock"
-
-    def _generate(self, messages: List[BaseMessage], stop: Optional[List[str]] = None, run_manager: Optional[Any] = None, **kwargs) -> Any:
-        raise NotImplementedError("Not needed for tests")
-
-    def invoke(self, input_str: str, **kwargs) -> str:
-        return "invalid json"
-
-
-@pytest.fixture
-def mock_retriever():
-    return MockRetriever()
-
-
-@pytest.fixture
-def mock_llm():
-    return MockLLM()
-
-
-def test_multi_hop_retriever_basic_functionality(mock_retriever, mock_llm):
-    """Test the basic functionality of MultiHopRetriever"""
-    retriever = MultiHopRetriever(
-        base_retriever=mock_retriever,
-        llm=mock_llm,
-        max_hops=2,
-        reformulation_template=TEST_TEMPLATE
-    )
-
-    # Test with a query that should trigger follow-up
-    docs = retriever._get_relevant_documents("Tell me about the Wright brothers")
-
-    # Should have documents from both queries
-    assert len(docs) == 2
-    assert any("Wright brothers" in doc.page_content for doc in docs)
-    assert any("WWI" in doc.page_content for doc in docs)
-
-
-def test_multi_hop_retriever_no_results(mock_retriever, mock_llm):
-    """Test behavior when no documents are found"""
-    retriever = MultiHopRetriever(
-        base_retriever=mock_retriever,
-        llm=mock_llm,
-        max_hops=2,
-        reformulation_template=TEST_TEMPLATE
-    )
-
-    # Test with a query that won't find any documents
-    docs = retriever._get_relevant_documents("Something unrelated")
-
-    # Should have no documents
-    assert len(docs) == 0
-
-
-def test_multi_hop_retriever_invalid_llm_output(mock_retriever):
-    """Test handling of invalid LLM output"""
-    retriever = MultiHopRetriever(
-        base_retriever=mock_retriever,
-        llm=InvalidOutputLLM(),
-        max_hops=2,
-        reformulation_template=TEST_TEMPLATE
-    )
-
-    # Should still work and return initial results
-    docs = retriever._get_relevant_documents("Tell me about the Wright brothers")
-    assert len(docs) == 1
-    assert "Wright brothers" in docs[0].page_content
-
-
-def test_multi_hop_retriever_max_hops(mock_retriever, mock_llm):
-    """Test that max_hops is respected"""
-    retriever = MultiHopRetriever(
-        base_retriever=mock_retriever,
-        llm=mock_llm,
-        max_hops=1,  # Only allow 1 hop
-        reformulation_template=TEST_TEMPLATE
-    )
-
-    # Should only get initial documents
-    docs = retriever._get_relevant_documents("Tell me about the Wright brothers")
-    assert len(docs) == 1
-    assert "Wright brothers" in docs[0].page_content
diff --git a/tests/unused/unit/broken/test_map_reduce_summarizer_chain.py b/tests/unused/unit/broken/test_map_reduce_summarizer_chain.py
deleted file mode 100644
index 2953a94ad6f..00000000000
--- a/tests/unused/unit/broken/test_map_reduce_summarizer_chain.py
+++ /dev/null
@@ -1,76 +0,0 @@
-from unittest.mock import AsyncMock, MagicMock
-
-import pandas as pd
-from langchain.chains.combine_documents.map_reduce import MapReduceDocumentsChain
-from langchain_core.documents import Document
-
-from mindsdb.integrations.libs.vectordatabase_handler import VectorStoreHandler
-from mindsdb.integrations.utilities.rag.chains.map_reduce_summarizer_chain import MapReduceSummarizerChain
-from mindsdb.integrations.utilities.rag.settings import SummarizationConfig
-from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator
-
-
-class TestMapReduceSummarizerChain:
-    def test_summarizes_documents(self):
-        mock_vector_store_handler = MagicMock(spec=VectorStoreHandler, wraps=VectorStoreHandler)
-        mock_vector_store_handler.select.side_effect = [
-            pd.DataFrame.from_records([
-                {'content': 'Chunk 1'},
-                {'content': 'Chunk 2'},
-            ]),
-            pd.DataFrame.from_records([
-                {'content': 'Chunk 3'}
-            ])
-        ]
-        mock_map_reduce_documents_chain = AsyncMock(spec=MapReduceDocumentsChain, wraps=MapReduceDocumentsChain)
-        mock_map_reduce_documents_chain.ainvoke.side_effect = [{'output_text': 'Final summary 1'}, {'output_text': 'Final summary 2'}]
-        test_summarizer_chain = MapReduceSummarizerChain(
-            vector_store_handler=mock_vector_store_handler,
-            map_reduce_documents_chain=mock_map_reduce_documents_chain,
-            summarization_config=SummarizationConfig()
-        )
-
-        chain_input = {
-            'context': [
-                Document(page_content='Chunk 1', metadata={'original_row_id': '1'}),
-                Document(page_content='Chunk 2', metadata={'original_row_id': '1'}),
-                Document(page_content='Chunk 3', metadata={'original_row_id': '2'})
-            ],
-            'question': 'What is the answer to life?',
-        }
-        actual_chain_output = test_summarizer_chain.invoke(chain_input)
-
-        # Make sure we select from the vector store correctly.
-        mock_vector_store_handler.select.assert_any_call(
-            'embeddings',
-            columns=['content', 'metadata'],
-            conditions=[FilterCondition(
-                "metadata->>'original_row_id'",
-                FilterOperator.EQUAL,
-                '1'
-            )]
-        )
-        mock_vector_store_handler.select.assert_any_call(
-            'embeddings',
-            columns=['content', 'metadata'],
-            conditions=[FilterCondition(
-                "metadata->>'original_row_id'",
-                FilterOperator.EQUAL,
-                '2'
-            )]
-        )
-
-        # Make sure we are calling the summarization chain with the right chunks.
-        mock_map_reduce_documents_chain.ainvoke.assert_awaited()
-
-        # Make sure the summary is actually added to the context.
-        expected_chain_output = {
-            'context': [
-                Document(page_content='Chunk 1', metadata={'original_row_id': '1', 'summary': 'Final summary 1'}),
-                Document(page_content='Chunk 2', metadata={'original_row_id': '1', 'summary': 'Final summary 1'}),
-                Document(page_content='Chunk 3', metadata={'original_row_id': '2', 'summary': 'Final summary 2'})
-            ],
-            'question': 'What is the answer to life?',
-        }
-
-        assert actual_chain_output == expected_chain_output
diff --git a/tests/unused/unit/broken/test_sql_retriever.py b/tests/unused/unit/broken/test_sql_retriever.py
deleted file mode 100644
index 7734739540b..00000000000
--- a/tests/unused/unit/broken/test_sql_retriever.py
+++ /dev/null
@@ -1,313 +0,0 @@
-from unittest.mock import MagicMock
-
-import pandas as pd
-from langchain_core.documents import Document
-from langchain_core.embeddings import Embeddings
-from langchain_core.outputs.generation import Generation
-from langchain_core.outputs.llm_result import LLMResult
-from langchain_core.retrievers import BaseRetriever
-from langchain_openai.chat_models.base import ChatOpenAI
-
-from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
-from mindsdb.integrations.libs.response import HandlerResponse
-from mindsdb.integrations.libs.vectordatabase_handler import DistanceFunction, VectorStoreHandler
-from mindsdb.integrations.utilities.rag.retrievers.sql_retriever import SQLRetriever
-from mindsdb.integrations.utilities.rag.settings import DEFAULT_METADATA_FILTERS_PROMPT_TEMPLATE, DEFAULT_SEMANTIC_PROMPT_TEMPLATE, ColumnSchema, MetadataSchema, SearchKwargs
-
-
-class TestSQLRetriever:
-    def test_basic(self):
-        llm = MagicMock(spec=ChatOpenAI, wraps=ChatOpenAI)
-        llm_result = MagicMock(spec=LLMResult, wraps=LLMResult)
-        llm_result.generations = [
-            [
-                Generation(
-                    text='''```json
-{
-    "filters": [
-        {
-            "attribute": "ContributorName",
-            "comparator": "=",
-            "value": "Alfred"
-        }
-    ]
-}
-```'''
-                )
-            ]
-        ]
-        llm.generate_prompt.return_value = llm_result
-        vector_db_mock = MagicMock(spec=VectorStoreHandler, wraps=VectorStoreHandler)
-        series = pd.Series(
-            [0, 'Chunk1', '[1.0, 2.0, 3.0]', {'key1': 'value1'}, 0, 1],
-            index=['id', 'content', 'embeddings', 'metadata', 'Id', 'Type']
-        )
-        df = pd.DataFrame([series])
-        vector_db_mock.native_query.return_value = HandlerResponse(
-            RESPONSE_TYPE.TABLE,
-            data_frame=df
-        )
-        embeddings_mock = MagicMock(spec=Embeddings, wraps=Embeddings)
-        embeddings_mock.embed_query.return_value = list(range(768))
-
-        source_schema = MetadataSchema(
-            table='test_source_table',
-            description='Contains source documents',
-            columns=[
-                ColumnSchema(name='Id', type='int', description='Unique ID as primary key of doc'),
-                ColumnSchema(name='Type', type='int', description='Document Type', values={1: 'Unknown', 2: 'Site Audit'})
-            ]
-        )
-        unit_schema = MetadataSchema(
-            table='unit',
-            description='Contains information about specific units of power plants. Several units can be part of a single plant.',
-            columns=[
-                ColumnSchema(name='UnitKey', type='int', description='Unique ID of the unit'),
-                ColumnSchema(name='PlantKey', type='int', description='ID of the plant the unit belongs to')
-            ]
-        )
-        plant_schema = MetadataSchema(
-            table='plant',
-            description='Contains information about specific power plants',
-            columns=[
-                ColumnSchema(name='PlantKey', type='int', description='The unique ID of the plant'),
-                ColumnSchema(name='PlantName', type='str', description='The name of the plant')
-            ]
-        )
-        document_unit_schema = MetadataSchema(
-            table='document_unit',
-            description='Links documents to the power plant they are relevant to',
-            columns=[
-                ColumnSchema(name='DocumentId', type='int', description='The ID of the document associated with the unit'),
-                ColumnSchema(name='UnitKey', type='int', description='The ID of the unit the documnet is associated with')
-            ]
-        )
-        all_schemas = [source_schema, unit_schema, plant_schema, document_unit_schema]
-        fallback_retriever = MagicMock(spec=BaseRetriever, wraps=BaseRetriever)
-        sql_retriever = SQLRetriever(
-            fallback_retriever=fallback_retriever,
-            vector_store_handler=vector_db_mock,
-            metadata_schemas=all_schemas,
-            embeddings_model=embeddings_mock,
-            metadata_filters_prompt_template=DEFAULT_METADATA_FILTERS_PROMPT_TEMPLATE,
-            rewrite_prompt_template=DEFAULT_SEMANTIC_PROMPT_TEMPLATE,
-            num_retries=2,
-            embeddings_table='test_embeddings_table',
-            source_table='test_source_table',
-            distance_function=DistanceFunction.SQUARED_EUCLIDEAN_DISTANCE,
-            search_kwargs=SearchKwargs(k=5),
-            llm=llm
-        )
-
-        docs = sql_retriever.invoke('What are Beaver Valley plant documents for nuclear fuel waste?')
-        # Make sure right doc was retrieved.
-        assert len(docs) == 1
-        assert docs[0].page_content == 'Chunk1'
-        assert docs[0].metadata == {'key1': 'value1'}
-
-    def test_retries(self):
-        llm = MagicMock(spec=ChatOpenAI, wraps=ChatOpenAI)
-        llm_result = MagicMock(spec=LLMResult, wraps=LLMResult)
-        llm_result.generations = [
-            [
-                Generation(
-                    text='''```json
-{
-    "filters": [
-        {
-            "attribute": "ContributorName",
-            "comparator": "=",
-            "value": "Alfred"
-        }
-    ]
-}
-```'''
-                )
-            ]
-        ]
-        llm.generate_prompt.return_value = llm_result
-        vector_db_mock = MagicMock(spec=VectorStoreHandler, wraps=VectorStoreHandler)
-        series = pd.Series(
-            [0, 'Chunk1', '[1.0, 2.0, 3.0]', {'key1': 'value1'}, 0, 1],
-            index=['id', 'content', 'embeddings', 'metadata', 'Id', 'Type']
-        )
-        df = pd.DataFrame([series])
-        vector_db_mock.native_query.side_effect = [
-            HandlerResponse(
-                RESPONSE_TYPE.ERROR,
-                error_message='Something went wrong I am in absolute shambles'
-            ),
-            HandlerResponse(
-                RESPONSE_TYPE.ERROR,
-                error_message='Something went wrong I am in absolute shambles'
-            ),
-            HandlerResponse(
-                RESPONSE_TYPE.TABLE,
-                data_frame=df
-            )
-        ]
-        embeddings_mock = MagicMock(spec=Embeddings, wraps=Embeddings)
-        embeddings_mock.embed_query.return_value = list(range(768))
-
-        source_schema = MetadataSchema(
-            table='test_source_table',
-            description='Contains source documents',
-            columns=[
-                ColumnSchema(name='Id', type='int', description='Unique ID as primary key of doc'),
-                ColumnSchema(name='Type', type='int', description='Document Type', values={1: 'Unknown', 2: 'Site Audit'})
-            ]
-        )
-        unit_schema = MetadataSchema(
-            table='unit',
-            description='Contains information about specific units of power plants. Several units can be part of a single plant.',
-            columns=[
-                ColumnSchema(name='UnitKey', type='int', description='Unique ID of the unit'),
-                ColumnSchema(name='PlantKey', type='int', description='ID of the plant the unit belongs to')
-            ]
-        )
-        plant_schema = MetadataSchema(
-            table='plant',
-            description='Contains information about specific power plants',
-            columns=[
-                ColumnSchema(name='PlantKey', type='int', description='The unique ID of the plant'),
-                ColumnSchema(name='PlantName', type='str', description='The name of the plant')
-            ]
-        )
-        document_unit_schema = MetadataSchema(
-            table='document_unit',
-            description='Links documents to the power plant they are relevant to',
-            columns=[
-                ColumnSchema(name='DocumentId', type='int', description='The ID of the document associated with the unit'),
-                ColumnSchema(name='UnitKey', type='int', description='The ID of the unit the documnet is associated with')
-            ]
-        )
-        all_schemas = [source_schema, unit_schema, plant_schema, document_unit_schema]
-        fallback_retriever = MagicMock(spec=BaseRetriever, wraps=BaseRetriever)
-        sql_retriever = SQLRetriever(
-            fallback_retriever=fallback_retriever,
-            vector_store_handler=vector_db_mock,
-            metadata_schemas=all_schemas,
-            embeddings_model=embeddings_mock,
-            metadata_filters_prompt_template=DEFAULT_METADATA_FILTERS_PROMPT_TEMPLATE,
-            rewrite_prompt_template=DEFAULT_SEMANTIC_PROMPT_TEMPLATE,
-            num_retries=3,
-            embeddings_table='test_embeddings_table',
-            source_table='test_source_table',
-            distance_function=DistanceFunction.SQUARED_EUCLIDEAN_DISTANCE,
-            search_kwargs=SearchKwargs(k=5),
-            llm=llm
-        )
-
-        docs = sql_retriever.invoke('What are Beaver Valley plant documents for nuclear fuel waste?')
-        # Make sure we retried.
-        assert len(vector_db_mock.native_query.mock_calls) == 3
-        # Make sure right doc was retrieved.
-        assert len(docs) == 1
-        assert docs[0].page_content == 'Chunk1'
-        assert docs[0].metadata == {'key1': 'value1'}
-
-    def test_fallback(self):
-        llm = MagicMock(spec=ChatOpenAI, wraps=ChatOpenAI)
-        llm_result = MagicMock(spec=LLMResult, wraps=LLMResult)
-        llm_result.generations = [
-            [
-                Generation(
-                    text='''```json
-{
-    "filters": [
-        {
-            "attribute": "ContributorName",
-            "comparator": "=",
-            "value": "Alfred"
-        }
-    ]
-}
-```'''
-                )
-            ]
-        ]
-        llm.generate_prompt.return_value = llm_result
-        vector_db_mock = MagicMock(spec=VectorStoreHandler, wraps=VectorStoreHandler)
-        vector_db_mock.native_query.side_effect = [
-            HandlerResponse(
-                RESPONSE_TYPE.ERROR,
-                error_message='Something went wrong I am in absolute shambles'
-            ),
-            HandlerResponse(
-                RESPONSE_TYPE.ERROR,
-                error_message='Something went wrong I am in absolute shambles'
-            ),
-            HandlerResponse(
-                RESPONSE_TYPE.ERROR,
-                error_message='Something went wrong I am in absolute shambles'
-            ),
-        ]
-        embeddings_mock = MagicMock(spec=Embeddings, wraps=Embeddings)
-        embeddings_mock.embed_query.return_value = list(range(768))
-
-        source_schema = MetadataSchema(
-            table='test_source_table',
-            description='Contains source documents',
-            columns=[
-                ColumnSchema(name='Id', type='int', description='Unique ID as primary key of doc'),
-                ColumnSchema(name='Type', type='int', description='Document Type', values={1: 'Unknown', 2: 'Site Audit'})
-            ]
-        )
-        unit_schema = MetadataSchema(
-            table='unit',
-            description='Contains information about specific units of power plants. Several units can be part of a single plant.',
-            columns=[
-                ColumnSchema(name='UnitKey', type='int', description='Unique ID of the unit'),
-                ColumnSchema(name='PlantKey', type='int', description='ID of the plant the unit belongs to')
-            ]
-        )
-        plant_schema = MetadataSchema(
-            table='plant',
-            description='Contains information about specific power plants',
-            columns=[
-                ColumnSchema(name='PlantKey', type='int', description='The unique ID of the plant'),
-                ColumnSchema(name='PlantName', type='str', description='The name of the plant')
-            ]
-        )
-        document_unit_schema = MetadataSchema(
-            table='document_unit',
-            description='Links documents to the power plant they are relevant to',
-            columns=[
-                ColumnSchema(name='DocumentId', type='int', description='The ID of the document associated with the unit'),
-                ColumnSchema(name='UnitKey', type='int', description='The ID of the unit the documnet is associated with')
-            ]
-        )
-        all_schemas = [source_schema, unit_schema, plant_schema, document_unit_schema]
-        fallback_retriever = MagicMock(spec=BaseRetriever, wraps=BaseRetriever)
-        fallback_retriever._get_relevant_documents.return_value = [
-            Document(
-                page_content='Chunk1',
-                metadata={
-                    'key1': 'value1'
-                }
-            )
-        ]
-        sql_retriever = SQLRetriever(
-            fallback_retriever=fallback_retriever,
-            vector_store_handler=vector_db_mock,
-            metadata_schemas=all_schemas,
-            embeddings_model=embeddings_mock,
-            metadata_filters_prompt_template=DEFAULT_METADATA_FILTERS_PROMPT_TEMPLATE,
-            rewrite_prompt_template=DEFAULT_SEMANTIC_PROMPT_TEMPLATE,
-            num_retries=2,
-            embeddings_table='test_embeddings_table',
-            source_table='test_source_table',
-            distance_function=DistanceFunction.SQUARED_EUCLIDEAN_DISTANCE,
-            search_kwargs=SearchKwargs(k=5),
-            llm=llm
-        )
-
-        docs = sql_retriever.invoke('What are Beaver Valley plant documents for nuclear fuel waste?')
-        # Make sure we retried.
-        assert len(vector_db_mock.native_query.mock_calls) == 3
-        # Make sure we falled back.
-        assert len(fallback_retriever._get_relevant_documents.mock_calls) == 1
-        # Make sure right doc was retrieved.
-        assert len(docs) == 1
-        assert docs[0].page_content == 'Chunk1'
-        assert docs[0].metadata == {'key1': 'value1'}
diff --git a/tests/unused/unit/handler_tests/test_pgvector_handler.py b/tests/unused/unit/handler_tests/test_pgvector_handler.py
index cc520bc4ee8..3eaa5316317 100644
--- a/tests/unused/unit/handler_tests/test_pgvector_handler.py
+++ b/tests/unused/unit/handler_tests/test_pgvector_handler.py
@@ -82,53 +82,3 @@ def test_select(self, handler):
         assert not result.empty
         for col in COLUMN_NAMES:
             assert col in result.columns
-
-    def test_hybrid_search_with_keywords(self, handler):
-        result = handler.hybrid_search(
-            TEST_TABLE_NAME,
-            # Embeddings (semantic) search.
-            [7.0, 8.0, 9.0],
-            # Keyword search.
-            query='cat rat'
-        )
-        # Top result is an exact embeddings match.
-        assert result.iloc[0]['embeddings'].tolist() == [7.0, 8.0, 9.0]
-        # Top result should include both keywords.
-        assert 'cat' in result.iloc[0]['content']
-        assert 'rat' in result.iloc[0]['content']
-
-    def test_hybrid_search_with_metadata(self, handler):
-        result = handler.hybrid_search(
-            TEST_TABLE_NAME,
-            # Embeddings (semantic) search.
-            [4.0, 5.0, 6.0],
-            # Metadata filters.
-            metadata={'location': 'Wonderland', 'author': 'Taishan'}
-        )
-        # Only two items match metadata filters.
-        assert len(result.index) == 2
-        # Top result is an exact embeddings match.
-        assert result.iloc[0]['embeddings'].tolist() == [4.0, 5.0, 6.0]
-
-    def test_hybrid_search_with_keywords_and_metadata(self, handler):
-        result = handler.hybrid_search(
-            TEST_TABLE_NAME,
-            # Embeddings (semantic) search.
-            [4.0, 5.0, 6.0],
-            # Keyword search.
-            query='fat cat',
-            # Metadata filters.
-            metadata={'location': 'Wonderland', 'author': 'Taishan'}
-        )
-        # Only two items match metadata filters.
-        assert len(result.index) == 2
-        # Top result is actually a keyword match because embeddings are close.
-        assert result.iloc[0]['embeddings'].tolist() == [1.0, 2.0, 3.0]
-
-    def test_hybrid_search_no_query_or_metadata(self, handler):
-        with pytest.raises(ValueError):
-            _ = handler.hybrid_search(
-                TEST_TABLE_NAME,
-                # Embeddings (semantic) search.
-                [4.0, 5.0, 6.0],
-            )
diff --git a/tests/unused/unit/handler_tests/test_rag_pipelines.py b/tests/unused/unit/handler_tests/test_rag_pipelines.py
deleted file mode 100644
index d2f884b8322..00000000000
--- a/tests/unused/unit/handler_tests/test_rag_pipelines.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import pytest
-import yaml
-from langchain_core.documents import Document
-from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-
-from mindsdb.integrations.utilities.rag.rag_pipeline_builder import RAG
-from pathlib import Path
-
-from mindsdb.integrations.utilities.rag.settings import DEFAULT_LLM_MODEL, RAGPipelineModel
-
-DEFAULT_LLM = ChatOpenAI(model_name=DEFAULT_LLM_MODEL, temperature=0)
-DEFAULT_EMBEDDINGS = OpenAIEmbeddings()
-
-path = Path(__file__).parent
-config_path = path / "data" / "rag_pipelines"
-pipeline_configs = list(config_path.glob('*.yml'))
-
-
-def create_test_documents():
-    return [
-        Document(
-            page_content="This is a test document",
-            metadata={"doc_id": "1"}
-        ),
-        Document(
-            page_content="This is also a test document",
-            metadata={"doc_id": "2"}
-        ),
-        Document(
-            page_content="This is another test document",
-            metadata={"doc_id": "3"}
-        )
-    ]
-
-
-@pytest.fixture(params=pipeline_configs, ids=lambda x: x.stem, scope='module')
-def config(request):
-    with open(request.param, 'r') as file:
-        config = yaml.safe_load(file)
-    config['documents'] = create_test_documents()
-    config['llm'] = DEFAULT_LLM
-    config['embedding_model'] = DEFAULT_EMBEDDINGS
-
-    return RAGPipelineModel(**config)
-
-
-def test_rag_pipeline_creation(config):
-    rag = RAG(config)
-    result = rag.pipeline.invoke('test document')
-
-    assert result is not None
-    assert isinstance(result, dict)
-    assert all(key in result for key in ['answer', 'context', 'question'])
diff --git a/tests/unused/unit/interfaces/agents/test_api_key_handling.py b/tests/unused/unit/interfaces/agents/test_api_key_handling.py
index 484ba775577..8a45b931d6c 100644
--- a/tests/unused/unit/interfaces/agents/test_api_key_handling.py
+++ b/tests/unused/unit/interfaces/agents/test_api_key_handling.py
@@ -12,10 +12,9 @@ class TestAgentApiKeyHandling(unittest.TestCase):
     def setUp(self):
         """Set up test environment."""
         # Mock environment variables
-        self.env_patcher = patch.dict(os.environ, {
-            'OPENAI_API_KEY': 'test-env-api-key',
-            'ANTHROPIC_API_KEY': 'test-env-anthropic-key'
-        })
+        self.env_patcher = patch.dict(
+            os.environ, {"OPENAI_API_KEY": "test-env-api-key", "ANTHROPIC_API_KEY": "test-env-anthropic-key"}
+        )
         self.env_patcher.start()
 
     def tearDown(self):
@@ -25,43 +24,44 @@ def tearDown(self):
     def test_get_api_key_from_env(self):
         """Test retrieving API key from environment variables."""
         # Test getting API key from environment variable
-        api_key = get_api_key('openai', {})
-        self.assertEqual(api_key, 'test-env-api-key')
+        api_key = get_api_key("openai", {})
+        self.assertEqual(api_key, "test-env-api-key")
 
     def test_get_api_key_from_args(self):
         """Test retrieving API key from create_args."""
         # Test getting API key from create_args
-        api_key = get_api_key('openai', {'openai_api_key': 'test-args-api-key'})
-        self.assertEqual(api_key, 'test-args-api-key')
+        api_key = get_api_key("openai", {"openai_api_key": "test-args-api-key"})
+        self.assertEqual(api_key, "test-args-api-key")
 
     def test_get_api_key_from_params(self):
         """Test retrieving API key from params dictionary."""
         # Test getting API key from params dictionary
-        api_key = get_api_key('openai', {'params': {'openai_api_key': 'test-params-api-key'}})
-        self.assertEqual(api_key, 'test-params-api-key')
+        api_key = get_api_key("openai", {"params": {"openai_api_key": "test-params-api-key"}})
+        self.assertEqual(api_key, "test-params-api-key")
 
     def test_get_api_key_priority(self):
         """Test API key retrieval priority."""
         # Test that create_args takes priority over environment variables
-        api_key = get_api_key('openai', {'openai_api_key': 'test-args-api-key'})
-        self.assertEqual(api_key, 'test-args-api-key')
+        api_key = get_api_key("openai", {"openai_api_key": "test-args-api-key"})
+        self.assertEqual(api_key, "test-args-api-key")
 
         # Test that params takes priority over environment variables
-        api_key = get_api_key('openai', {'params': {'openai_api_key': 'test-params-api-key'}})
-        self.assertEqual(api_key, 'test-params-api-key')
+        api_key = get_api_key("openai", {"params": {"openai_api_key": "test-params-api-key"}})
+        self.assertEqual(api_key, "test-params-api-key")
 
         # Test that create_args takes priority over params
-        api_key = get_api_key('openai', {
-            'openai_api_key': 'test-args-api-key',
-            'params': {'openai_api_key': 'test-params-api-key'}
-        })
-        self.assertEqual(api_key, 'test-args-api-key')
-
-    @patch('mindsdb.interfaces.agents.agents_controller.AgentsController.check_model_provider')
-    @patch('mindsdb.interfaces.agents.agents_controller.AgentsController.get_agent')
-    @patch('mindsdb.interfaces.agents.agents_controller.ProjectController')
-    @patch('mindsdb.interfaces.storage.db.session')
-    def test_add_agent_with_api_key(self, mock_session, mock_project_controller, mock_get_agent, mock_check_model_provider):
+        api_key = get_api_key(
+            "openai", {"openai_api_key": "test-args-api-key", "params": {"openai_api_key": "test-params-api-key"}}
+        )
+        self.assertEqual(api_key, "test-args-api-key")
+
+    @patch("mindsdb.interfaces.agents.agents_controller.AgentsController.check_model_provider")
+    @patch("mindsdb.interfaces.agents.agents_controller.AgentsController.get_agent")
+    @patch("mindsdb.interfaces.agents.agents_controller.ProjectController")
+    @patch("mindsdb.interfaces.storage.db.session")
+    def test_add_agent_with_api_key(
+        self, mock_session, mock_project_controller, mock_get_agent, mock_check_model_provider
+    ):
         """Test adding an agent with an API key in params."""
         # Mock project controller
         mock_project = MagicMock()
@@ -71,36 +71,31 @@ def test_add_agent_with_api_key(self, mock_session, mock_project_controller, moc
         mock_get_agent.return_value = None
 
         # Mock check_model_provider to return a provider
-        mock_check_model_provider.return_value = (None, 'openai')
+        mock_check_model_provider.return_value = (None, "openai")
 
         # Create an instance of AgentsController
         agent_controller = AgentsController()
 
         # Test adding an agent with an API key in params
-        params = {
-            'openai_api_key': 'test-agent-api-key',
-            'other_param': 'value'
-        }
+        params = {"openai_api_key": "test-agent-api-key", "other_param": "value"}
 
         # Create a mock agent with proper params
         mock_agent = MagicMock()
         mock_agent.params = params.copy()  # Set params directly
 
         # Mock db.Agents to return our prepared mock agent
-        with patch('mindsdb.interfaces.storage.db.Agents', return_value=mock_agent):
+        with patch("mindsdb.interfaces.storage.db.Agents", return_value=mock_agent):
             # Add the agent
             agent = agent_controller.add_agent(
-                name='test_agent',
-                project_name='mindsdb',
-                model_name='gpt-4',
-                skills=[],
-                provider='openai',
-                params=params
+                name="test_agent",
+                project_name="mindsdb",
+                model={"model_name": "gpt-4", "provider": "openai"},
+                params=params,
             )
 
         # Verify that the API key was preserved in the params
-        self.assertEqual(agent.params.get('openai_api_key'), 'test-agent-api-key')
+        self.assertEqual(agent.params.get("openai_api_key"), "test-agent-api-key")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()
diff --git a/tests/unused/unit/ml_handlers/test_rag.py b/tests/unused/unit/ml_handlers/test_rag.py
deleted file mode 100644
index f5d7777276a..00000000000
--- a/tests/unused/unit/ml_handlers/test_rag.py
+++ /dev/null
@@ -1,324 +0,0 @@
-import os
-import time
-
-import pandas as pd
-import pytest
-from mindsdb_sql_parser import parse_sql
-
-from tests.unit.executor_test_base import BaseExecutorTest
-
-OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
-os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
-
-WRITER_API_KEY = os.environ.get("WRITER_API_KEY")
-os.environ["WRITER_API_KEY"] = WRITER_API_KEY
-
-WRITER_ORG_ID = os.environ.get("WRITER_ORG_ID")
-os.environ["WRITER_ORG_ID"] = WRITER_ORG_ID
-
-
-class TestRAG(BaseExecutorTest):
-    def wait_predictor(self, project, name):
-        # wait
-        done = False
-        for attempt in range(200):
-            ret = self.run_sql(f"select * from {project}.models where name='{name}'")
-            if not ret.empty:
-                if ret["STATUS"][0] == "complete":
-                    done = True
-                    break
-                elif ret["STATUS"][0] == "error":
-                    break
-            time.sleep(0.5)
-        if not done:
-            raise RuntimeError("predictor wasn't created")
-
-    def run_sql(self, sql):
-        ret = self.command_executor.execute_command(parse_sql(sql))
-        assert ret.error_code is None
-        if ret.data is not None:
-            return ret.data.to_df()
-
-    def test_missing_required_keys(self):
-        # create project
-        self.run_sql("create database proj")
-
-        self.run_sql(
-            """
-                CREATE MODEL proj.test_rag_handler_missing_required_args
-                PREDICT answer
-                USING
-                   engine="rag"
-                   """
-        )
-        with pytest.raises(Exception):
-            self.wait_predictor("proj", "test_rag_handler_missing_required_args")
-
-    def test_invalid_model_id_parameter(self):
-        # create project
-
-        self.run_sql("create database proj")
-        self.run_sql(
-            f"""
-              create model proj.test_rag_openai_nonexistant_model
-              predict answer
-              using
-                engine='rag',
-                llm_type='openai',
-                model_id='this-model-does-not-exist',
-                openai_api_key='{OPENAI_API_KEY}';
-           """
-        )
-        with pytest.raises(Exception):
-            self.wait_predictor("proj", "test_rag_openai_nonexistant_model")
-
-        self.run_sql(
-            f"""
-                  create model proj.test_rag_writer_nonexistant_model
-                  predict answer
-                  using
-                    engine='rag',
-                    llm_type='writer',
-                    model_id='this-model-does-not-exist',
-                    writer_api_key='{WRITER_API_KEY}',
-                    writer_org_id='{WRITER_ORG_ID}';
-               """
-        )
-
-        with pytest.raises(Exception):
-            self.wait_predictor("proj", "test_rag_writer_nonexistant_model")
-
-    def test_unsupported_llm_type(self):
-        self.run_sql("create database proj")
-        self.run_sql(
-            """
-            create model proj.test_unsupported_llm
-            predict answer
-            using
-                engine='rag',
-                llm_type='unsupported_llm'
-        """
-        )
-        with pytest.raises(Exception):
-            self.wait_predictor("proj", "test_unsupported_llm")
-
-    def test_unsupported_vector_store(self):
-        self.run_sql("create database proj")
-        self.run_sql(
-            f"""
-            create model proj.test_unsupported_vector_store
-            predict answer
-            using
-                engine='rag',
-                llm_type='openai',
-                openai_api_key='{OPENAI_API_KEY}',
-                vector_store_name='unsupported_vector_store'
-        """
-        )
-
-        with pytest.raises(Exception):
-            self.wait_predictor("proj", "test_unsupported_vector_store")
-
-    def test_unknown_arguments(self):
-        self.run_sql("create database proj")
-        self.run_sql(
-            f"""
-            create model proj.test_openai_unknown_arguments
-            predict answer
-            using
-                engine='rag',
-                llm_type='openai',
-                openai_api_key='{OPENAI_API_KEY}',
-                evidently_wrong_argument='wrong value'  --- this is a wrong argument name
-        """
-        )
-        with pytest.raises(Exception):
-            self.wait_predictor("proj", "test_openai_unknown_arguments")
-
-    def test_qa(self):
-        # create project
-        self.run_sql("create database proj")
-        df = pd.DataFrame.from_dict(
-            {
-                "context": [
-                    "For adults and children age 5 and older, OTC decongestants, "
-                    "antihistamines and pain relievers might offer some symptom relief. "
-                    "However, they won't prevent a cold or shorten its duration, and most have some side effects.",
-                    "Paracetamol, also known as acetaminophen and APAP, "
-                    "is a medication used to treat pain and fever as well as colds and flu. "
-                    "It is typically used for mild to moderate pain relief. "
-                    "Evidence is mixed for its use to relieve fever in children. "
-                    "It is often sold in combination with other medications, such as in many cold medications.",
-                    "lemsip is a brand of over-the-counter pharmaceuticals used to treat cold and flu symptoms. "
-                    "The brand is currently owned by Reckitt Benckiser. "
-                    "The original Lemsip product contained paracetamol as its active ingredient. "
-                    "However, other products marketed under the Lemsip "
-                    "brand contain other active ingredients such as ibuprofen,"
-                    "pseudoephedrine, phenylephrine, and guaifenesin."
-                ],
-                "url": [
-                    "https://docs.mindsdb.com/sql/tutorials/recommenders/",
-                    "https://docs.mindsdb.com/sql/tutorials/llm-chatbot-ui/",
-                    "https://docs.mindsdb.com/sql/tutorials/house-sales-forecasting/",
-                ],
-            }
-        )
-        self.save_file("df", df)
-
-        # test openai qa with chromadb
-
-        self.run_sql(
-            f"""
-           create model proj.test_rag_openai_qa
-           from files (select * from df)
-           predict answer
-           using
-             engine='rag',
-             llm_type='openai',
-             openai_api_key='{OPENAI_API_KEY}',
-             vector_store_folder_name='rag_openai_qa_test',
-             input_column='question'
-        """
-        )
-        self.wait_predictor("proj", "test_rag_openai_qa")
-
-        result_df = self.run_sql(
-            """
-            SELECT p.answer
-            FROM proj.test_rag_openai_qa as p
-            WHERE question='What is the best treatment for a cold?'
-        """
-        )
-        assert result_df["answer"].iloc[0]
-
-        # test batching with openai qa chroma
-
-        embeddings_batch_size = 1
-
-        self.run_sql(
-            f"""
-           create model proj.test_rag_openai_qa_batch
-           from files (select * from df)
-           predict answer
-           using
-             engine='rag',
-             llm_type='openai',
-             openai_api_key='{OPENAI_API_KEY}',
-             vector_store_folder_name='rag_openai_qa_test_batch',
-             embeddings_batch_size={embeddings_batch_size},
-             input_column='question'
-        """
-        )
-
-        self.wait_predictor("proj", "test_rag_openai_qa_batch")
-
-        result_df = self.run_sql(
-            """
-            SELECT p.answer
-            FROM proj.test_rag_openai_qa_batch as p
-            WHERE question='What is the best treatment for a cold?'
-        """
-        )
-        assert result_df["answer"].iloc[0]
-
-        # test writer qa with FAISS
-
-        self.run_sql(
-            f"""
-           create model proj.test_rag_writer_qa
-           from files (select * from df)
-           predict answer
-           using
-             engine='rag',
-             llm_type='writer',
-             vector_store_name='faiss',
-             writer_api_key='{WRITER_API_KEY}',
-             writer_org_id='{WRITER_ORG_ID}',
-             vector_store_folder_name='rag_writer_qa_test',
-             input_column='question'
-        """
-        )
-        self.wait_predictor("proj", "test_rag_writer_qa")
-
-        result_df = self.run_sql(
-            """
-            SELECT p.answer
-            FROM proj.test_rag_writer_qa as p
-            WHERE question='What is the best treatment for a cold?'
-        """
-        )
-        assert result_df["answer"].iloc[0]
-
-        # test single url parsing
-        self.run_sql(
-            f"""
-           create model proj.test_rag_writer_qa_single_url
-           predict answer
-           using
-             engine='rag',
-             llm_type='writer',
-             url='https://docs.mindsdb.com/sql/tutorials/recommenders/',
-             vector_store_name='faiss',
-             writer_api_key='{WRITER_API_KEY}',
-             writer_org_id='{WRITER_ORG_ID}',
-             vector_store_folder_name='rag_writer_qa_test_single_url',
-             input_column='question'
-        """
-        )
-        self.wait_predictor("proj", "test_rag_writer_qa_single_url")
-
-        result_df = self.run_sql(
-            """
-            SELECT p.answer
-            FROM proj.test_rag_writer_qa as p
-            WHERE question='What recommender models does mindsdb support?'
-        """
-        )
-        assert result_df["answer"].iloc[0]
-
-        # test multi url parsing
-        self.run_sql(
-            f"""
-           create model proj.test_rag_writer_qa_multi_url
-           from files (select * from df)
-           predict answer
-           using
-             engine='rag',
-             llm_type='writer',
-             vector_store_name='faiss',
-             url_column_name='url',
-             writer_api_key='{WRITER_API_KEY}',
-             writer_org_id='{WRITER_ORG_ID}',
-             vector_store_folder_name='rag_writer_qa_test_multi_url',
-             input_column='question'
-        """
-        )
-
-        self.wait_predictor("proj", "test_rag_writer_qa_multi_url")
-
-        result_df = self.run_sql(
-            """
-            SELECT p.answer
-            FROM proj.test_rag_writer_qa_multi_url as p
-            WHERE question='which chat app currently works with mindsdb chatbot?'
-        """
-        )
-
-        assert result_df["answer"].iloc[0]
-
-    def test_invalid_prompt_template(self):
-        # create project
-        self.run_sql("create database proj")
-        self.run_sql(
-            f"""
-           create model proj.test_invalid_prompt_template_format
-           predict completion
-           using
-             engine='rag',
-             llm_type="openai",
-             prompt_template="not valid format",
-             openai_api_key='{OPENAI_API_KEY}';
-        """
-        )
-        with pytest.raises(Exception):
-            self.wait_predictor("proj", "test_invalid_prompt_template_format")