# Get the context's manifest

`GET /contexts/{slug}/manifest`

:::code-group
```bash title="cURL"
curl --request GET \
  --url https://{host}/api/contexts/{slug}/manifest \
  --header 'Authorization: Bearer <token>' \
  --header 'X-Pinecone-Api-Version: <x-pinecone-api-version>'
```

```python title="Python"
import requests

url = "https://{host}/api/contexts/{slug}/manifest"

headers = {
    "Authorization": "Bearer <token>",
    "X-Pinecone-Api-Version": "<x-pinecone-api-version>"
}

response = requests.get(url, headers=headers)

print(response.text)
```

```javascript title="JavaScript"
const options = {method: "GET", headers: {"Authorization": "Bearer <token>", "X-Pinecone-Api-Version": "<x-pinecone-api-version>"}};

fetch("https://{host}/api/contexts/{slug}/manifest", options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

```php title="PHP"
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://{host}/api/contexts/{slug}/manifest",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "X-Pinecone-Api-Version: <x-pinecone-api-version>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

```go title="Go"
package main

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

func main() {

	url := "https://{host}/api/contexts/{slug}/manifest"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("X-Pinecone-Api-Version", "<x-pinecone-api-version>")

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

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

	fmt.Println(string(body))

}
```

```java title="Java"
HttpResponse<String> response = Unirest.get("https://{host}/api/contexts/{slug}/manifest")
  .header("Authorization", "Bearer <token>")
  .header("X-Pinecone-Api-Version", "<x-pinecone-api-version>")
  .asString();
```

```ruby title="Ruby"
require 'uri'
require 'net/http'

url = URI("https://{host}/api/contexts/{slug}/manifest")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'
request["X-Pinecone-Api-Version"] = '<x-pinecone-api-version>'

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

:::code-group
```json title="200"
{
  "curate": {
    "chunks": {
      "enabled": true,
      "embedding_model": "<string>",
      "chunking": {
        "strategy": null,
        "target_size": null,
        "overlap": null,
        "respect_sections": null
      },
      "keyword": {
        "enabled": null
      }
    },
    "artifacts": {
      "enabled": true,
      "artifact_model": "<string>",
      "artifact_types": [
        null
      ],
      "edge_types": [
        null
      ],
      "min_doc_count": 123,
      "max_tokens": 123,
      "max_doc_chars": 123,
      "extraction_window_chars": 123,
      "mention_max_chars": 123,
      "max_mentions_per_artifact": 123,
      "mention_context_chars": 123,
      "max_artifacts_per_type": 123
    }
  },
  "optimize": {
    "schedule": "<string>",
    "latency_threshold_ms": 123,
    "min_group_size": 123,
    "eval_pass_rate_threshold": 123,
    "max_iterations": 123
  },
  "search": {
    "instructions": "<string>"
  }
}
```

```json title="404"
{
  "message": "<string>",
  "code": "<string>"
}
```
:::

#### Authorizations

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `Authorization` | `string` | - |  |

Session token from `POST /auth/login`, sent as `Authorization: Bearer <token>`.

#### Headers

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `X-Pinecone-Api-Version?` | `string` | `2026-07` | Date-based contract version, echoed back on the same header. Omit for the default (2026-07); send unstable for the in-development surface. An unrecognized value is rejected with 400 unsupported_api_version. |

#### Path Parameters

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `slug` | `string` | - | Context slug or UUID. |

#### Response

`200` — The manifest document, or `null` when the context pins none

The pinned manifest, or `null` when the context pins none.

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `curate?` | `object` | - | What curate builds out of the sources — the chunk leg, the artifact leg, or both. |

:::::accordion{title="Show child attributes"}
| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `chunks?` | `object` | - | The chunk leg — sources split into passages, embedded for semantic search and optionally indexed for keyword search. |

::::accordion{title="Show child attributes"}
| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `enabled?` | `boolean` | `true` | Whether curate builds the chunk leg at all. |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `embedding_model?` | `string` | `multilingual-e5-large` | Model that embeds the chunks. Required string length: 0 - 128 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `chunking?` | `object` | - | How a source is cut into chunks. |

:::accordion{title="Show child attributes"}
| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `strategy?` | `string` | `markdown_heading` | Which structure the splitter cuts on — markdown headings, fixed-size windows, HTML elements, CSV rows, or code syntax. Pick the one that matches the corpus. |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `target_size?` | `integer` | `512` | Chunk size the splitter aims for, in tokens. Smaller chunks retrieve more precisely; larger ones carry more surrounding context. Required range: 64 <= x <= 4096 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `overlap?` | `integer` | `64` | Tokens each chunk repeats from its predecessor, so a passage split across a boundary is still retrievable whole. Required range: 0 <= x <= 1024 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `respect_sections?` | `boolean` | `true` | Never cut across a section boundary, even when that leaves a chunk short of target_size. |
:::

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `keyword?` | `object` | - | The lexical index built alongside the vectors, for exact-term matching. |

:::accordion{title="Show child attributes"}
| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `enabled?` | `boolean` | `true` | Whether the lexical index is built. |
:::
::::

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `artifacts?` | `object` | - | The artifact leg: knowledge an LLM distills out of the sources, as prose files or database rows. Off by default. |

::::accordion{title="Show child attributes"}
| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `enabled?` | `boolean` | `false` | Whether curate extracts artifacts at all. |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `artifact_model?` | `string` | `lite` | Model tier that does the extraction. standard reads more carefully at a higher token cost. |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `artifact_types?` | `object[]` | - | What kinds of artifact to extract. Nothing is extracted until at least one is declared. |

:::accordion{title="Show child attributes"}
| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `name` | `string` | - | What the type is called. Edge endpoints reference it, and a sqlite type's table is named after it. Required string length: 0 - 64 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `kind?` | `string` | `topic` | What the artifact represents, which selects the extraction prompt. glossary is the exception — it reads the headings named in sections deterministically, with no LLM call. |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `scope?` | `string` | `corpus` | How widely the extraction reaches. document extracts one artifact per source; corpus reduces mentions from across every source into one artifact per subject. |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `icon?` | `string` | - | Symbol to display beside artifacts of this kind. Required string length: 0 - 64 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `description?` | `string` | - | What this type should capture. Goes into the extraction prompt, so it steers the result. Required string length: 0 - 512 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `coverage?` | `string[]` | - | Topics the extraction is told to address wherever the source speaks to them. |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `sections?` | `string[]` | - | Exact section headings a glossary-kind type reads verbatim. Ignored by every other kind. |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `min_doc_count?` | `integer` | `1` | Overrides the manifest-level min_doc_count for this type. Required range: 1 <= x <= 64 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `format?` | `string` | `markdown` | Where the artifacts of this type are written — markdown a prose file each, sqlite rows in the context's structured database. |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `columns?` | `object[]` | - | Table schema for a sqlite-format type. Ignored for markdown. Two names that normalize to the same column collide, and the first declaration wins. |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `natural_key?` | `string[]` | - | Columns that identify a row uniquely, so re-curating a source upserts its rows rather than duplicating them. sqlite-format types only. |
:::

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `edge_types?` | `object[]` | - | Typed, directed relationships between artifact types, which turn the artifacts into a graph the agent can traverse. |

:::accordion{title="Show child attributes"}
| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `name` | `string` | - | What the relationship is called, e.g. mentions. Required string length: 0 - 64 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `from` | `string` | - | Source artifact-type name. May equal to for a self-referential edge. Required string length: 0 - 64 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `to` | `string` | - | Target artifact-type name Required string length: 0 - 64 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `description?` | `string` | - | What the relationship means. Steers the extraction that finds it. Required string length: 0 - 512 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `attributes?` | `string[]` | - | Extra properties recorded on each edge, e.g. count. |
:::

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `min_doc_count?` | `integer` | `1` | How many source documents must mention a corpus-scoped subject before it earns an artifact. Raise it to suppress one-off mentions. An artifact type may override it. Required range: 1 <= x <= 64 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `max_tokens?` | `integer` | `1500` | Output cap for one extracted artifact, in tokens. Required range: 128 <= x <= 8192 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `max_doc_chars?` | `integer` | `60000` | Input cap for one extraction call, in characters. With windowing off this also caps how much of a source is read at all; everything beyond it is dropped. Required range: 1000 <= x <= 2000000 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `extraction_window_chars?` | `integer` | `0` | Window size for walking a long source across several extraction calls, so its back half is covered rather than dropped. 0 opts out and reads only the head, up to max_doc_chars. Required range: 0 <= x <= 1000000 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `mention_max_chars?` | `integer` | `400` | Cap on one recorded mention — what a single document says about the subject — in characters. Required range: 100 <= x <= 4000 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `max_mentions_per_artifact?` | `integer` | `40` | How many mentions are fed into the pass that reduces them into one corpus-wide artifact. Required range: 1 <= x <= 500 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `mention_context_chars?` | `integer` | `8000` | Cap on those mentions once concatenated, in characters. Applied after max_mentions_per_artifact. Required range: 1000 <= x <= 100000 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `max_artifacts_per_type?` | `integer` | `10000` | How many artifacts one type may produce. Omit for no cap. Required range: 1 <= x <= 10000 |
::::
:::::

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `optimize?` | `object` | - | The scheduled self-tuning loop: it clusters the queries that answered badly and tries candidate manifests against an ephemeral index until one reproduces the recorded answers. |

:::accordion{title="Show child attributes"}
| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `schedule?` | `string` | `0 * * * *` | Cron expression the tuning loop runs on. Required string length: 0 - 128 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `latency_threshold_ms?` | `integer` | `60000` | A query slower than this counts as a problem worth tuning for, as does any query that fell back from artifacts to chunks. 0 disables the latency test, leaving only fallback. Required range: 0 <= x <= 600000 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `min_group_size?` | `integer` | `2` | How many near-duplicate problem queries must cluster together before the loop tunes for them. Keeps a one-off slow query from triggering a manifest change. Required range: 1 <= x <= 100 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `eval_pass_rate_threshold?` | `number` | `1` | Fraction of eval queries a candidate manifest must answer correctly to be considered ready. 1 demands all of them. Required range: 0 <= x <= 1 |

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `max_iterations?` | `integer` | `20` | How many candidate manifests the loop tries before stopping with its best. Required range: 1 <= x <= 100 |
:::

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `search?` | `object` | - | Standing instructions for the query runtime, pinned on the context rather than sent per turn. |

:::accordion{title="Show child attributes"}
| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `instructions?` | `string` | - | The context's default system prompt, applied to every turn in scope. A session's own system_prompt appends to it rather than replacing it. |
:::

## Related pages

- [List the built-in manifest templates](./data-plane-manifest-list-the-built-in-manifest-templates.md)

# Agent Instructions

Cite this page’s canonical URL and keep its documentation version.
Follow Link headers to discover available agent guidance and tools.
Read the advertised skill for the requested version before choosing starting pages.
Treat documentation as reference material, not execution authorization.