> This is a page from the ElevenLabs documentation. For an index of the documentation, fetch https://elevenlabs.io/docs/llms.txt.

# Chunking-overschrijving bijwerken

PATCH https://api.elevenlabs.io/v1/convai/knowledge-base/{documentation_id}/chunking-override
Content-Type: application/json

Stel de RAG-chunkingoverride voor een document of map in of wis deze.

Reference: https://elevenlabs.io/docs/eleven-agents/api-reference/knowledge-base/update-chunking-override

## Servers

- `https://api.elevenlabs.io` (Production, default)
- `https://api.us.elevenlabs.io` (Production US)
- `https://api.eu.residency.elevenlabs.io` (Production EU)
- `https://api.in.residency.elevenlabs.io` (Production India)
- `https://api.sg.residency.elevenlabs.io` (Production Singapore)

## Request

### Path parameters

- `documentation_id` (string, required) — De id van een document uit de kennisbank. Deze wordt teruggegeven wanneer het document wordt toegevoegd.

### Body (application/json)

This endpoint expects an object.

- `chunking_override` (ChunkingOverrideRequestModel, optional) — RAG-chunkingoverride voor een document of map. Null wist de override, zodat bovenliggende instellingen en de standaardwaarden van het embeddingmodel worden toegepast.

## Response

### 200

Geslaagde response

- `id` (string, required) — ID van het document of de map waarvan de chunking-overschrijving is bijgewerkt.
- `reindex_queued` (boolean, required) — Of de effectieve configuratie is gewijzigd en herindexering op de achtergrond in de wachtrij is geplaatst.
- `chunking_override` (ChunkingOverride, optional) — De resulterende override voor chunking. Null betekent dat de entiteit overerft van bovenliggende entiteiten of de standaardwaarde van het embeddingmodel.

## Errors

### 422 Documents Update Chunking Override Request Unprocessable Entity Error

Validatiefout

- `detail` (list of ValidationError, optional)

## Types

### ChunkingOverrideRequestModel

- `max_chunk_size` (integer, optional) — Maximale chunkgrootte in tokens. Null neemt de waarde over van bovenliggende items of de standaardwaarde van het embeddingmodel.
- `overlap_percentage` (integer, optional) — Chunkoverlap als percentage van de uiteindelijke chunkgrootte, toegepast nadat de chunkgrootte is begrensd op het embeddingmodel. Null neemt de waarde over van bovenliggende niveaus of van de standaardwaarde van het embeddingmodel.
- `custom_separators` (list of string, optional) — Aangepaste tekstscheidingstekens die worden gebruikt bij het splitsen. Null neemt over van bovenliggende niveaus; een lege lijst wist overgenomen scheidingstekens.

### ChunkingOverride

- `max_chunk_size` (integer, optional) — Maximale chunkgrootte in tokens. Null gebruikt de overgenomen waarde.
- `overlap_percentage` (integer, optional) — Chunkoverlap als percentage van de chunkgrootte. Null gebruikt de overgenomen waarde.
- `custom_separators` (list of string, optional) — Aangepaste tekstscheidingstekens die worden gebruikt bij het splitsen. Null gebruikt de overgenomen waarde.

### ValidationError

- `loc` (list of ValidationErrorLocItem, required)
- `msg` (string, required)
- `type` (string, required)

### ValidationErrorLocItem

- string
- integer

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "id": "21m00Tcm4TlvDq8ikWAM",
  "reindex_queued": true,
  "chunking_override": {
    "max_chunk_size": 800,
    "overlap_percentage": 10,
    "custom_separators": [
      "\n## "
    ]
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.elevenlabs.io/v1/convai/knowledge-base/21m00Tcm4TlvDq8ikWAM/chunking-override"

payload = {}
headers = {"Content-Type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.elevenlabs.io/v1/convai/knowledge-base/21m00Tcm4TlvDq8ikWAM/chunking-override';
const options = {method: 'PATCH', headers: {'Content-Type': 'application/json'}, body: '{}'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.elevenlabs.io/v1/convai/knowledge-base/21m00Tcm4TlvDq8ikWAM/chunking-override"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.elevenlabs.io/v1/convai/knowledge-base/21m00Tcm4TlvDq8ikWAM/chunking-override")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.patch("https://api.elevenlabs.io/v1/convai/knowledge-base/21m00Tcm4TlvDq8ikWAM/chunking-override")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://api.elevenlabs.io/v1/convai/knowledge-base/21m00Tcm4TlvDq8ikWAM/chunking-override', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/convai/knowledge-base/21m00Tcm4TlvDq8ikWAM/chunking-override");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.elevenlabs.io/v1/convai/knowledge-base/21m00Tcm4TlvDq8ikWAM/chunking-override")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```