@orq-ai/node 3.4.0-rc.37 → 3.5.11

package/{docs/sdks/memorystores → packages/orq-rc/docs/sdks/knowledge}/README.md

@@ -1,29 +1,29 @@
-# MemoryStores
-(*memoryStores*)
+# Knowledge
+(*knowledge*)
 
 ## Overview
 
 ### Available Operations
 
-* [list](#list) - List memory stores
-* [create](#create) - Create memory store
-* [retrieve](#retrieve) - Retrieve memory store
-* [update](#update) - Update memory store
-* [delete](#delete) - Delete memory store
-* [listMemories](#listmemories) - List all memories
-* [createMemory](#creatememory) - Create a new memory
-* [retrieveMemory](#retrievememory) - Retrieve a specific memory
-* [updateMemory](#updatememory) - Update a specific memory
-* [deleteMemory](#deletememory) - Delete a specific memory
-* [listDocuments](#listdocuments) - List all documents for a memory
-* [createDocument](#createdocument) - Create a new memory document
-* [retrieveDocument](#retrievedocument) - Retrieve a specific memory document
-* [updateDocument](#updatedocument) - Update a specific memory document
-* [deleteDocument](#deletedocument) - Delete a specific memory document
+* [list](#list) - List all knowledge bases
+* [create](#create) - Create a knowledge
+* [retrieve](#retrieve) - Retrieves a knowledge base
+* [update](#update) - Updates a knowledge
+* [delete](#delete) - Deletes a knowledge
+* [listDatasources](#listdatasources) - List all datasources
+* [createDatasource](#createdatasource) - Create a new datasource
+* [retrieveDatasource](#retrievedatasource) - Retrieve a datasource
+* [deleteDatasource](#deletedatasource) - Deletes a datasource
+* [updateDatasource](#updatedatasource) - Update a datasource
+* [createChunks](#createchunks) - Create chunks for a datasource
+* [listChunks](#listchunks) - List all chunks for a datasource
+* [updateChunk](#updatechunk) - Update a chunk
+* [deleteChunk](#deletechunk) - Delete a chunk
+* [retrieveChunk](#retrievechunk) - Retrieve a chunk
 
 ## list
 
-Retrieves a paginated list of memory stores in the workspace. Use cursor-based pagination parameters to navigate through the results.
+Returns a list of your knowledge bases. The knowledge bases are returned sorted by creation date, with the most recent knowledge bases appearing first
 
 ### Example Usage
 
@@ -35,7 +35,7 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.list({});
+  const result = await orq.knowledge.list({});
 
   // Handle the result
   console.log(result);
@@ -50,7 +50,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresList } from "@orq-ai/node/funcs/memoryStoresList.js";
+import { knowledgeList } from "@orq-ai/node/funcs/knowledgeList.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -59,7 +59,7 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresList(orq, {});
+  const res = await knowledgeList(orq, {});
 
   if (!res.ok) {
     throw res.error;
@@ -78,25 +78,24 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.GetAllMemoryStoresRequest](../../models/operations/getallmemorystoresrequest.md)                                                                                   | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.ListKnowledgeBasesRequest](../../models/operations/listknowledgebasesrequest.md)                                                                                   | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.GetAllMemoryStoresResponseBody](../../models/operations/getallmemorystoresresponsebody.md)\>**
+**Promise\<[operations.ListKnowledgeBasesResponseBody](../../models/operations/listknowledgebasesresponsebody.md)\>**
 
 ### Errors
 
-| Error Type          | Status Code         | Content Type        |
-| ------------------- | ------------------- | ------------------- |
-| errors.HonoApiError | 401                 | application/json    |
-| errors.APIError     | 4XX, 5XX            | \*/\*               |
+| Error Type      | Status Code     | Content Type    |
+| --------------- | --------------- | --------------- |
+| errors.APIError | 4XX, 5XX        | \*/\*           |
 
 ## create
 
-Create memory store
+Create a knowledge
 
 ### Example Usage
 
@@ -108,13 +107,10 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.create({
+  const result = await orq.knowledge.create({
     key: "<key>",
-    embeddingConfig: {
-      model: "google-ai/text-embedding-004",
-    },
-    description: "delightfully fumigate convection though zowie up bulky electronics",
-    path: "Customer Service/Billing/Refund",
+    embeddingModel: "<value>",
+    path: "Default",
   });
 
   // Handle the result
@@ -130,7 +126,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresCreate } from "@orq-ai/node/funcs/memoryStoresCreate.js";
+import { knowledgeCreate } from "@orq-ai/node/funcs/knowledgeCreate.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -139,13 +135,10 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresCreate(orq, {
+  const res = await knowledgeCreate(orq, {
     key: "<key>",
-    embeddingConfig: {
-      model: "google-ai/text-embedding-004",
-    },
-    description: "delightfully fumigate convection though zowie up bulky electronics",
-    path: "Customer Service/Billing/Refund",
+    embeddingModel: "<value>",
+    path: "Default",
   });
 
   if (!res.ok) {
@@ -165,25 +158,24 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.CreateMemoryStoreRequestBody](../../models/operations/creatememorystorerequestbody.md)                                                                             | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.CreateKnowledgeRequestBody](../../models/operations/createknowledgerequestbody.md)                                                                                 | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.CreateMemoryStoreResponseBody](../../models/operations/creatememorystoreresponsebody.md)\>**
+**Promise\<[operations.CreateKnowledgeResponseBody](../../models/operations/createknowledgeresponsebody.md)\>**
 
 ### Errors
 
-| Error Type          | Status Code         | Content Type        |
-| ------------------- | ------------------- | ------------------- |
-| errors.HonoApiError | 400                 | application/json    |
-| errors.APIError     | 4XX, 5XX            | \*/\*               |
+| Error Type      | Status Code     | Content Type    |
+| --------------- | --------------- | --------------- |
+| errors.APIError | 4XX, 5XX        | \*/\*           |
 
 ## retrieve
 
-Retrieves detailed information about a specific memory store, including its configuration and metadata.
+Retrieve a knowledge base with the settings.
 
 ### Example Usage
 
@@ -195,8 +187,8 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.retrieve({
-    memoryStoreKey: "<value>",
+  const result = await orq.knowledge.retrieve({
+    knowledgeId: "<id>",
   });
 
   // Handle the result
@@ -212,7 +204,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresRetrieve } from "@orq-ai/node/funcs/memoryStoresRetrieve.js";
+import { knowledgeRetrieve } from "@orq-ai/node/funcs/knowledgeRetrieve.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -221,8 +213,8 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresRetrieve(orq, {
-    memoryStoreKey: "<value>",
+  const res = await knowledgeRetrieve(orq, {
+    knowledgeId: "<id>",
   });
 
   if (!res.ok) {
@@ -242,25 +234,24 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.RetrieveMemoryStoreRequest](../../models/operations/retrievememorystorerequest.md)                                                                                 | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.GetOneKnowledgeRequest](../../models/operations/getoneknowledgerequest.md)                                                                                         | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.RetrieveMemoryStoreResponseBody](../../models/operations/retrievememorystoreresponsebody.md)\>**
+**Promise\<[operations.GetOneKnowledgeResponseBody](../../models/operations/getoneknowledgeresponsebody.md)\>**
 
 ### Errors
 
-| Error Type          | Status Code         | Content Type        |
-| ------------------- | ------------------- | ------------------- |
-| errors.HonoApiError | 401, 403, 404       | application/json    |
-| errors.APIError     | 4XX, 5XX            | \*/\*               |
+| Error Type      | Status Code     | Content Type    |
+| --------------- | --------------- | --------------- |
+| errors.APIError | 4XX, 5XX        | \*/\*           |
 
 ## update
 
-Update the memory store configuration
+Updates a knowledge
 
 ### Example Usage
 
@@ -272,14 +263,10 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.update({
-    memoryStoreKey: "<value>",
+  const result = await orq.knowledge.update({
+    knowledgeId: "<id>",
     requestBody: {
-      embeddingConfig: {
-        model: "jina/jina-embeddings-v2-base-de",
-      },
-      description: "technician eulogise whereas till mild than during",
-      path: "Customer Service/Billing/Refund",
+      path: "Default",
     },
   });
 
@@ -296,7 +283,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresUpdate } from "@orq-ai/node/funcs/memoryStoresUpdate.js";
+import { knowledgeUpdate } from "@orq-ai/node/funcs/knowledgeUpdate.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -305,14 +292,10 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresUpdate(orq, {
-    memoryStoreKey: "<value>",
+  const res = await knowledgeUpdate(orq, {
+    knowledgeId: "<id>",
     requestBody: {
-      embeddingConfig: {
-        model: "jina/jina-embeddings-v2-base-de",
-      },
-      description: "technician eulogise whereas till mild than during",
-      path: "Customer Service/Billing/Refund",
+      path: "Default",
     },
   });
 
@@ -333,14 +316,14 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.UpdateMemoryStoreRequest](../../models/operations/updatememorystorerequest.md)                                                                                     | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.UpdateKnowledgeRequest](../../models/operations/updateknowledgerequest.md)                                                                                         | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.UpdateMemoryStoreResponseBody](../../models/operations/updatememorystoreresponsebody.md)\>**
+**Promise\<[operations.UpdateKnowledgeResponseBody](../../models/operations/updateknowledgeresponsebody.md)\>**
 
 ### Errors
 
@@ -350,7 +333,7 @@ run();
 
 ## delete
 
-Permanently delete a memory store, including memories and documents.
+Deletes a knowledge base. Deleting a knowledge base will delete all the datasources and chunks associated with it.
 
 ### Example Usage
 
@@ -362,8 +345,8 @@ const orq = new Orq({
 });
 
 async function run() {
-  await orq.memoryStores.delete({
-    memoryStoreKey: "<value>",
+  await orq.knowledge.delete({
+    knowledgeId: "<id>",
   });
 
 
@@ -378,7 +361,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresDelete } from "@orq-ai/node/funcs/memoryStoresDelete.js";
+import { knowledgeDelete } from "@orq-ai/node/funcs/knowledgeDelete.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -387,8 +370,8 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresDelete(orq, {
-    memoryStoreKey: "<value>",
+  const res = await knowledgeDelete(orq, {
+    knowledgeId: "<id>",
   });
 
   if (!res.ok) {
@@ -407,7 +390,7 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.DeleteMemoryStoreRequest](../../models/operations/deletememorystorerequest.md)                                                                                     | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.DeleteKnowledgeRequest](../../models/operations/deleteknowledgerequest.md)                                                                                         | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
@@ -422,9 +405,9 @@ run();
 | --------------- | --------------- | --------------- |
 | errors.APIError | 4XX, 5XX        | \*/\*           |
 
-## listMemories
+## listDatasources
 
-Retrieves a paginated list of memories for the memory store
+List all datasources
 
 ### Example Usage
 
@@ -436,8 +419,9 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.listMemories({
-    memoryStoreKey: "<value>",
+  const result = await orq.knowledge.listDatasources({
+    knowledgeId: "<id>",
+    status: "completed",
   });
 
   // Handle the result
@@ -453,7 +437,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresListMemories } from "@orq-ai/node/funcs/memoryStoresListMemories.js";
+import { knowledgeListDatasources } from "@orq-ai/node/funcs/knowledgeListDatasources.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -462,8 +446,9 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresListMemories(orq, {
-    memoryStoreKey: "<value>",
+  const res = await knowledgeListDatasources(orq, {
+    knowledgeId: "<id>",
+    status: "completed",
   });
 
   if (!res.ok) {
@@ -483,14 +468,14 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.GetAllMemoriesRequest](../../models/operations/getallmemoriesrequest.md)                                                                                           | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.ListDatasourcesRequest](../../models/operations/listdatasourcesrequest.md)                                                                                         | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.GetAllMemoriesResponseBody](../../models/operations/getallmemoriesresponsebody.md)\>**
+**Promise\<[operations.ListDatasourcesResponseBody](../../models/operations/listdatasourcesresponsebody.md)\>**
 
 ### Errors
 
@@ -498,9 +483,9 @@ run();
 | --------------- | --------------- | --------------- |
 | errors.APIError | 4XX, 5XX        | \*/\*           |
 
-## createMemory
+## createDatasource
 
-Creates a new memory in the specified memory store.
+Create a new datasource
 
 ### Example Usage
 
@@ -512,8 +497,9 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.createMemory({
-    memoryStoreKey: "<value>",
+  const result = await orq.knowledge.createDatasource({
+    knowledgeId: "<id>",
+    requestBody: {},
   });
 
   // Handle the result
@@ -529,7 +515,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresCreateMemory } from "@orq-ai/node/funcs/memoryStoresCreateMemory.js";
+import { knowledgeCreateDatasource } from "@orq-ai/node/funcs/knowledgeCreateDatasource.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -538,8 +524,9 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresCreateMemory(orq, {
-    memoryStoreKey: "<value>",
+  const res = await knowledgeCreateDatasource(orq, {
+    knowledgeId: "<id>",
+    requestBody: {},
   });
 
   if (!res.ok) {
@@ -559,14 +546,14 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.CreateMemoryRequest](../../models/operations/creatememoryrequest.md)                                                                                               | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.CreateDatasourceRequest](../../models/operations/createdatasourcerequest.md)                                                                                       | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.CreateMemoryResponseBody](../../models/operations/creatememoryresponsebody.md)\>**
+**Promise\<[operations.CreateDatasourceResponseBody](../../models/operations/createdatasourceresponsebody.md)\>**
 
 ### Errors
 
@@ -574,9 +561,9 @@ run();
 | --------------- | --------------- | --------------- |
 | errors.APIError | 4XX, 5XX        | \*/\*           |
 
-## retrieveMemory
+## retrieveDatasource
 
-Retrieves details of a specific memory by its ID
+Retrieve a datasource
 
 ### Example Usage
 
@@ -588,9 +575,9 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.retrieveMemory({
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
+  const result = await orq.knowledge.retrieveDatasource({
+    knowledgeId: "<id>",
+    datasourceId: "<id>",
   });
 
   // Handle the result
@@ -606,7 +593,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresRetrieveMemory } from "@orq-ai/node/funcs/memoryStoresRetrieveMemory.js";
+import { knowledgeRetrieveDatasource } from "@orq-ai/node/funcs/knowledgeRetrieveDatasource.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -615,9 +602,9 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresRetrieveMemory(orq, {
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
+  const res = await knowledgeRetrieveDatasource(orq, {
+    knowledgeId: "<id>",
+    datasourceId: "<id>",
   });
 
   if (!res.ok) {
@@ -637,14 +624,14 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.RetrieveMemoryRequest](../../models/operations/retrievememoryrequest.md)                                                                                           | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.RetrieveDatasourceRequest](../../models/operations/retrievedatasourcerequest.md)                                                                                   | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.RetrieveMemoryResponseBody](../../models/operations/retrievememoryresponsebody.md)\>**
+**Promise\<[operations.RetrieveDatasourceResponseBody](../../models/operations/retrievedatasourceresponsebody.md)\>**
 
 ### Errors
 
@@ -652,9 +639,9 @@ run();
 | --------------- | --------------- | --------------- |
 | errors.APIError | 4XX, 5XX        | \*/\*           |
 
-## updateMemory
+## deleteDatasource
 
-Updates the details of a specific memory.
+Deletes a datasource from a knowledge base. Deleting a datasource will remove it from the knowledge base and all associated chunks. This action is irreversible and cannot be undone.
 
 ### Example Usage
 
@@ -666,13 +653,12 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.updateMemory({
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
+  await orq.knowledge.deleteDatasource({
+    knowledgeId: "<id>",
+    datasourceId: "<id>",
   });
 
-  // Handle the result
-  console.log(result);
+
 }
 
 run();
@@ -684,7 +670,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresUpdateMemory } from "@orq-ai/node/funcs/memoryStoresUpdateMemory.js";
+import { knowledgeDeleteDatasource } from "@orq-ai/node/funcs/knowledgeDeleteDatasource.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -693,9 +679,9 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresUpdateMemory(orq, {
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
+  const res = await knowledgeDeleteDatasource(orq, {
+    knowledgeId: "<id>",
+    datasourceId: "<id>",
   });
 
   if (!res.ok) {
@@ -704,8 +690,7 @@ async function run() {
 
   const { value: result } = res;
 
-  // Handle the result
-  console.log(result);
+  
 }
 
 run();
@@ -715,14 +700,14 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.UpdateMemoryRequest](../../models/operations/updatememoryrequest.md)                                                                                               | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.DeleteDatasourceRequest](../../models/operations/deletedatasourcerequest.md)                                                                                       | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.UpdateMemoryResponseBody](../../models/operations/updatememoryresponsebody.md)\>**
+**Promise\<void\>**
 
 ### Errors
 
@@ -730,14 +715,9 @@ run();
 | --------------- | --------------- | --------------- |
 | errors.APIError | 4XX, 5XX        | \*/\*           |
 
-## deleteMemory
+## updateDatasource
 
-Permanently deletes a specific memory.
-
-        Use this endpoint to:
-        - Remove a memory from the store
-        - Clean up unused memories
-        - Manage memory storage space
+Update a datasource
 
 ### Example Usage
 
@@ -749,12 +729,16 @@ const orq = new Orq({
 });
 
 async function run() {
-  await orq.memoryStores.deleteMemory({
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
+  const result = await orq.knowledge.updateDatasource({
+    knowledgeId: "<id>",
+    datasourceId: "<id>",
+    requestBody: {
+      displayName: "Tony_Roberts",
+    },
   });
 
-
+  // Handle the result
+  console.log(result);
 }
 
 run();
@@ -766,7 +750,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresDeleteMemory } from "@orq-ai/node/funcs/memoryStoresDeleteMemory.js";
+import { knowledgeUpdateDatasource } from "@orq-ai/node/funcs/knowledgeUpdateDatasource.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -775,9 +759,12 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresDeleteMemory(orq, {
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
+  const res = await knowledgeUpdateDatasource(orq, {
+    knowledgeId: "<id>",
+    datasourceId: "<id>",
+    requestBody: {
+      displayName: "Tony_Roberts",
+    },
   });
 
   if (!res.ok) {
@@ -786,7 +773,8 @@ async function run() {
 
   const { value: result } = res;
 
-  
+  // Handle the result
+  console.log(result);
 }
 
 run();
@@ -796,14 +784,14 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.DeleteMemoryRequest](../../models/operations/deletememoryrequest.md)                                                                                               | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.UpdateDatasourceRequest](../../models/operations/updatedatasourcerequest.md)                                                                                       | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<void\>**
+**Promise\<[operations.UpdateDatasourceResponseBody](../../models/operations/updatedatasourceresponsebody.md)\>**
 
 ### Errors
 
@@ -811,9 +799,9 @@ run();
 | --------------- | --------------- | --------------- |
 | errors.APIError | 4XX, 5XX        | \*/\*           |
 
-## listDocuments
+## createChunks
 
-Retrieves a paginated list of documents associated with a specific memory.
+Create chunks for a datasource
 
 ### Example Usage
 
@@ -825,9 +813,9 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.listDocuments({
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
+  const result = await orq.knowledge.createChunks({
+    knowledgeId: "<id>",
+    datasourceId: "<id>",
   });
 
   // Handle the result
@@ -843,7 +831,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresListDocuments } from "@orq-ai/node/funcs/memoryStoresListDocuments.js";
+import { knowledgeCreateChunks } from "@orq-ai/node/funcs/knowledgeCreateChunks.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -852,9 +840,9 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresListDocuments(orq, {
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
+  const res = await knowledgeCreateChunks(orq, {
+    knowledgeId: "<id>",
+    datasourceId: "<id>",
   });
 
   if (!res.ok) {
@@ -874,14 +862,14 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.GetAllMemoryDocumentsRequest](../../models/operations/getallmemorydocumentsrequest.md)                                                                             | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.CreateChunkRequest](../../models/operations/createchunkrequest.md)                                                                                                 | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.GetAllMemoryDocumentsResponseBody](../../models/operations/getallmemorydocumentsresponsebody.md)\>**
+**Promise\<[operations.CreateChunkResponseBody[]](../../models/.md)\>**
 
 ### Errors
 
@@ -889,9 +877,9 @@ run();
 | --------------- | --------------- | --------------- |
 | errors.APIError | 4XX, 5XX        | \*/\*           |
 
-## createDocument
+## listChunks
 
-Creates a new document in the specified memory.
+List all chunks for a datasource
 
 ### Example Usage
 
@@ -903,9 +891,10 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.createDocument({
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
+  const result = await orq.knowledge.listChunks({
+    knowledgeId: "<id>",
+    datasourceId: "<id>",
+    status: "completed",
   });
 
   // Handle the result
@@ -921,7 +910,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresCreateDocument } from "@orq-ai/node/funcs/memoryStoresCreateDocument.js";
+import { knowledgeListChunks } from "@orq-ai/node/funcs/knowledgeListChunks.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -930,9 +919,10 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresCreateDocument(orq, {
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
+  const res = await knowledgeListChunks(orq, {
+    knowledgeId: "<id>",
+    datasourceId: "<id>",
+    status: "completed",
   });
 
   if (!res.ok) {
@@ -952,14 +942,14 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.CreateMemoryDocumentRequest](../../models/operations/creatememorydocumentrequest.md)                                                                               | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.ListChunksRequest](../../models/operations/listchunksrequest.md)                                                                                                   | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.CreateMemoryDocumentResponseBody](../../models/operations/creatememorydocumentresponsebody.md)\>**
+**Promise\<[operations.ListChunksResponseBody](../../models/operations/listchunksresponsebody.md)\>**
 
 ### Errors
 
@@ -967,9 +957,9 @@ run();
 | --------------- | --------------- | --------------- |
 | errors.APIError | 4XX, 5XX        | \*/\*           |
 
-## retrieveDocument
+## updateChunk
 
-Retrieves details of a specific memory document by its ID.
+Update a chunk
 
 ### Example Usage
 
@@ -981,10 +971,10 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.retrieveDocument({
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
-    documentId: "<id>",
+  const result = await orq.knowledge.updateChunk({
+    chunkId: "<id>",
+    datasourceId: "<id>",
+    knowledgeId: "<id>",
   });
 
   // Handle the result
@@ -1000,7 +990,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresRetrieveDocument } from "@orq-ai/node/funcs/memoryStoresRetrieveDocument.js";
+import { knowledgeUpdateChunk } from "@orq-ai/node/funcs/knowledgeUpdateChunk.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -1009,10 +999,10 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresRetrieveDocument(orq, {
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
-    documentId: "<id>",
+  const res = await knowledgeUpdateChunk(orq, {
+    chunkId: "<id>",
+    datasourceId: "<id>",
+    knowledgeId: "<id>",
   });
 
   if (!res.ok) {
@@ -1032,14 +1022,14 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.RetrieveMemoryDocumentRequest](../../models/operations/retrievememorydocumentrequest.md)                                                                           | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.UpdateChunkRequest](../../models/operations/updatechunkrequest.md)                                                                                                 | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.RetrieveMemoryDocumentResponseBody](../../models/operations/retrievememorydocumentresponsebody.md)\>**
+**Promise\<[operations.UpdateChunkResponseBody](../../models/operations/updatechunkresponsebody.md)\>**
 
 ### Errors
 
@@ -1047,9 +1037,9 @@ run();
 | --------------- | --------------- | --------------- |
 | errors.APIError | 4XX, 5XX        | \*/\*           |
 
-## updateDocument
+## deleteChunk
 
-Updates the details of a specific memory document.
+Delete a chunk
 
 ### Example Usage
 
@@ -1061,14 +1051,13 @@ const orq = new Orq({
 });
 
 async function run() {
-  const result = await orq.memoryStores.updateDocument({
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
-    documentId: "<id>",
+  await orq.knowledge.deleteChunk({
+    chunkId: "<id>",
+    datasourceId: "<id>",
+    knowledgeId: "<id>",
   });
 
-  // Handle the result
-  console.log(result);
+
 }
 
 run();
@@ -1080,7 +1069,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresUpdateDocument } from "@orq-ai/node/funcs/memoryStoresUpdateDocument.js";
+import { knowledgeDeleteChunk } from "@orq-ai/node/funcs/knowledgeDeleteChunk.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -1089,10 +1078,10 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresUpdateDocument(orq, {
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
-    documentId: "<id>",
+  const res = await knowledgeDeleteChunk(orq, {
+    chunkId: "<id>",
+    datasourceId: "<id>",
+    knowledgeId: "<id>",
   });
 
   if (!res.ok) {
@@ -1101,8 +1090,7 @@ async function run() {
 
   const { value: result } = res;
 
-  // Handle the result
-  console.log(result);
+  
 }
 
 run();
@@ -1112,14 +1100,14 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.UpdateMemoryDocumentRequest](../../models/operations/updatememorydocumentrequest.md)                                                                               | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.DeleteChunkRequest](../../models/operations/deletechunkrequest.md)                                                                                                 | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<[operations.UpdateMemoryDocumentResponseBody](../../models/operations/updatememorydocumentresponsebody.md)\>**
+**Promise\<void\>**
 
 ### Errors
 
@@ -1127,14 +1115,9 @@ run();
 | --------------- | --------------- | --------------- |
 | errors.APIError | 4XX, 5XX        | \*/\*           |
 
-## deleteDocument
+## retrieveChunk
 
-Permanently deletes a specific memory document.
-
-        Use this endpoint to:
-        - Remove a document from a memory
-        - Clean up unused documents
-        - Manage document storage space
+Retrieve a chunk
 
 ### Example Usage
 
@@ -1146,13 +1129,14 @@ const orq = new Orq({
 });
 
 async function run() {
-  await orq.memoryStores.deleteDocument({
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
-    documentId: "<id>",
+  const result = await orq.knowledge.retrieveChunk({
+    chunkId: "<id>",
+    datasourceId: "<id>",
+    knowledgeId: "<id>",
   });
 
-
+  // Handle the result
+  console.log(result);
 }
 
 run();
@@ -1164,7 +1148,7 @@ The standalone function version of this method:
 
 ```typescript
 import { OrqCore } from "@orq-ai/node/core.js";
-import { memoryStoresDeleteDocument } from "@orq-ai/node/funcs/memoryStoresDeleteDocument.js";
+import { knowledgeRetrieveChunk } from "@orq-ai/node/funcs/knowledgeRetrieveChunk.js";
 
 // Use `OrqCore` for best tree-shaking performance.
 // You can create one instance of it to use across an application.
@@ -1173,10 +1157,10 @@ const orq = new OrqCore({
 });
 
 async function run() {
-  const res = await memoryStoresDeleteDocument(orq, {
-    memoryStoreKey: "<value>",
-    memoryId: "<id>",
-    documentId: "<id>",
+  const res = await knowledgeRetrieveChunk(orq, {
+    chunkId: "<id>",
+    datasourceId: "<id>",
+    knowledgeId: "<id>",
   });
 
   if (!res.ok) {
@@ -1185,7 +1169,8 @@ async function run() {
 
   const { value: result } = res;
 
-  
+  // Handle the result
+  console.log(result);
 }
 
 run();
@@ -1195,14 +1180,14 @@ run();
 
 | Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.DeleteMemoryDocumentRequest](../../models/operations/deletememorydocumentrequest.md)                                                                               | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
+| `request`                                                                                                                                                                      | [operations.GetOneChunkRequest](../../models/operations/getonechunkrequest.md)                                                                                                 | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
 | `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
 | `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
 | `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
 
 ### Response
 
-**Promise\<void\>**
+**Promise\<[operations.GetOneChunkResponseBody](../../models/operations/getonechunkresponsebody.md)\>**
 
 ### Errors