Replace documents

The dialect's update spelling of the write above, and the same act: an upsert keyed by the index's primary key.

PUT /v1/index/indexes/{uid}/documents

Index → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/index/indexes/{uid}/documents`
Method	`PUT`
Operation	`put_index_indexes_by_uid_documents`
Auth	`Authorization: Bearer $HANZO_API_KEY`

The dialect's update spelling of the write above, and the same act: an upsert keyed by the index's primary key. The JS client's addDocuments and updateDocuments both reduce to this for whole documents, so both spellings are served and both behave identically.

The tenant is the org minted from the VALIDATED bearer's owner claim, never a client-supplied header. Without a validated principal the answer is 403 carrying the dialect's invalid_api_key body.

The 202 and its enqueued task are DIALECT COMPATIBILITY, not a promise of later work: the write is already applied when this answers.

Request

2 fields, body application/json.

Field	In	Type	Required	Description
`uid`	path	string	yes
`(body)`	body	any[] \| object	yes

Response

Status	Body	Meaning
`2XX`	indexEnqueued	Success

2XX body — 5 fields.

Field	In	Type	Always
`enqueuedAt`	body	string	—
`indexUid`	body	string	—
`status`	body	string	—
`taskUid`	body	integer	—
`type`	body	string	—

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo index indexes documents replace <uid>

.ts

.py

.go

.rs

.java

import { Configuration, IndexApi } from 'hanzoai';

const api = new IndexApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.putIndexIndexesByUidDocuments({ uid: 'uid' });

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import IndexApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = IndexApi(client).put_index_indexes_by_uid_documents(uid='uid')

cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.IndexAPI.PutIndexIndexesByUidDocuments(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, index_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = index_api::put_index_indexes_by_uid_documents(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.IndexApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new IndexApi(client).putIndexIndexesByUidDocuments();

curl -X PUT https://api.hanzo.ai/v1/index/indexes/<uid>/documents \
  -H "Authorization: Bearer $HANZO_API_KEY"

MCP reaches index through the index tool, which names its 14 operations with its own verbs — this one among them, under a name only MCP declares. describe explains any of them:

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "get_index_health"
         }
       }
     }'

Index API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousCreate indexes NextDelete middlewares