> ## Documentation Index
> Fetch the complete documentation index at: https://docs.pinecone.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Get the context's manifest

> The context's pinned manifest document. A context that pins nothing returns `null` — the runtime fills defaults. Writes go through the `manifest` field on `PUT /contexts/{slug}`.



## OpenAPI

````yaml https://raw.githubusercontent.com/pinecone-io/pinecone-api/refs/heads/main/2026-07/nexus_data_2026-07.oas.yaml get /contexts/{slug}/manifest
openapi: 3.0.3
info:
  title: Nexus API
  description: >
    Nexus turns a set of sources into a queryable, self-improving knowledge
    base. A context is **sources + a manifest**: upload sources, **curate** them
    into a searchable index, then query it. The manifest, one validated JSON
    document, defines how the context indexes, retrieves and answers.


    Curate is explicit — nothing is queryable until you run it. `{slug}` accepts
    a context's slug or its UUID. Query with `POST /api/query`, one turn per
    call, and read the answer from `output[].content[].text`; multi-turn
    conversations are sessions. Tasks are project-owned at `/api/tasks`, not
    nested under contexts.
  contact:
    name: Pinecone Support
    url: https://support.pinecone.io
    email: support@pinecone.io
  license:
    name: Apache 2.0
    url: https://www.apache.org/licenses/LICENSE-2.0
  version: 2026-07
servers:
  - url: https://{host}/api
    description: Your Nexus deployment host
    variables:
      host:
        default: api.example.com
        description: Host of your Nexus deployment.
security:
  - bearerAuth: []
  - apiKey: []
tags:
  - name: Auth
    description: Login and identity.
  - name: Project
    description: The active Pinecone project and its disclosure state.
  - name: Contexts
    description: A context is sources + a manifest. Curate it explicitly before querying.
  - name: Manifest
    description: Manifest templates and the per-context manifest.
  - name: Source Files
    description: >-
      Per-context source imports (upload, connector, public repo) and the source
      file tree.
  - name: Knowledge
    description: Read-only browse of curated knowledge (chunks + artifacts).
  - name: Curation
    description: Curate workflow trigger, curation ledger, and version-pin primitives.
  - name: Connectors
    description: >-
      Project-level links to external source providers (Box, ...). Linked via
      OAuth or an API key, then used to import source documents into a context.
  - name: Query
    description: >-
      The unified KnowQL Query API: run a query turn (`/query`), fetch a turn
      (`/queries/{id}`), inspect its trace, manage feedback, comparison flags,
      and multi-turn sessions (`/sessions`).
  - name: Tasks
    description: >-
      Top-level, project-owned task records for every workflow (optimize,
      curate, search, work, explore, profile, import, pack, restore, groom).
  - name: Task Files
    description: Read, list, and delete files from live or archived task containers.
paths:
  /contexts/{slug}/manifest:
    get:
      tags:
        - Manifest
      summary: Get the context's manifest
      description: >-
        The context's pinned manifest document. A context that pins nothing
        returns `null` — the runtime fills defaults. Writes go through the
        `manifest` field on `PUT /contexts/{slug}`.
      operationId: get_context_manifest
      parameters:
        - in: path
          name: slug
          description: Context slug or UUID.
          required: true
          schema:
            type: string
          style: simple
        - in: header
          name: X-Pinecone-Api-Version
          description: >-
            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`.
          schema:
            default: 2026-07
            x-enum:
              - 2026-07
              - unstable
            type: string
          style: simple
      responses:
        '200':
          description: The manifest document, or `null` when the context pins none
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/NullableManifest'
        '404':
          description: Not found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
components:
  schemas:
    NullableManifest:
      nullable: true
      description: The pinned manifest, or `null` when the context pins none.
      type: object
      allOf:
        - description: >-
            The document that drives curate and search. Sparse: every field is
            optional and an omitted one falls back to its default, so absent
            fields are omitted rather than nulled. A change reaches the index on
            the next curate; rebuilding what is already indexed needs a forced
            one.
          x-component-name: Manifest
          type: object
          properties:
            curate:
              description: >-
                What curate builds out of the sources — the chunk leg, the
                artifact leg, or both.
              x-component-name: CurateManifest
              type: object
              properties:
                chunks:
                  description: >-
                    The chunk leg — sources split into passages, embedded for
                    semantic search and optionally indexed for keyword search.
                  x-component-name: ChunksConfig
                  type: object
                  properties:
                    enabled:
                      description: Whether curate builds the chunk leg at all.
                      default: true
                      type: boolean
                    embedding_model:
                      description: Model that embeds the chunks.
                      default: multilingual-e5-large
                      type: string
                      maxLength: 128
                    chunking:
                      description: How a source is cut into chunks.
                      x-component-name: ChunkingConfig
                      type: object
                      properties:
                        strategy:
                          description: >-
                            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.
                          default: markdown_heading
                          x-enum:
                            - markdown_heading
                            - sliding_window
                            - html
                            - csv
                            - code
                          type: string
                        target_size:
                          description: >-
                            Chunk size the splitter aims for, in tokens. Smaller
                            chunks retrieve more precisely; larger ones carry
                            more surrounding context.
                          default: 512
                          type: integer
                          minimum: 64
                          maximum: 4096
                        overlap:
                          description: >-
                            Tokens each chunk repeats from its predecessor, so a
                            passage split across a boundary is still retrievable
                            whole.
                          default: 64
                          type: integer
                          minimum: 0
                          maximum: 1024
                        respect_sections:
                          description: >-
                            Never cut across a section boundary, even when that
                            leaves a chunk short of `target_size`.
                          default: true
                          type: boolean
                    keyword:
                      description: >-
                        The lexical index built alongside the vectors, for
                        exact-term matching.
                      type: object
                      properties:
                        enabled:
                          description: Whether the lexical index is built.
                          default: true
                          type: boolean
                artifacts:
                  description: >-
                    The artifact leg: knowledge an LLM distills out of the
                    sources, as prose files or database rows. Off by default.
                  x-component-name: ArtifactsConfig
                  type: object
                  properties:
                    enabled:
                      description: Whether curate extracts artifacts at all.
                      default: false
                      type: boolean
                    artifact_model:
                      description: >-
                        Model tier that does the extraction. `standard` reads
                        more carefully at a higher token cost.
                      default: lite
                      x-enum:
                        - standard
                        - lite
                      type: string
                    artifact_types:
                      description: >-
                        What kinds of artifact to extract. Nothing is extracted
                        until at least one is declared.
                      type: array
                      items:
                        description: >-
                          One kind of artifact to extract. `name` is required of
                          a written manifest; a read echoes a stored document
                          that lacks one rather than failing.
                        x-component-name: ArtifactType
                        type: object
                        properties:
                          name:
                            description: >-
                              What the type is called. Edge endpoints reference
                              it, and a sqlite type's table is named after it.
                            type: string
                            maxLength: 64
                          kind:
                            description: >-
                              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.
                            default: topic
                            x-enum:
                              - summary
                              - topic
                              - entity
                              - event
                              - doc
                              - page
                              - glossary
                            type: string
                          scope:
                            description: >-
                              How widely the extraction reaches. `document`
                              extracts one artifact per source; `corpus` reduces
                              mentions from across every source into one
                              artifact per subject.
                            default: corpus
                            x-enum:
                              - document
                              - corpus
                            type: string
                          icon:
                            description: Symbol to display beside artifacts of this kind.
                            type: string
                            maxLength: 64
                          description:
                            description: >-
                              What this type should capture. Goes into the
                              extraction prompt, so it steers the result.
                            type: string
                            maxLength: 512
                          coverage:
                            description: >-
                              Topics the extraction is told to address wherever
                              the source speaks to them.
                            type: array
                            items:
                              description: One topic the extraction should address.
                              type: string
                              maxLength: 128
                            maxItems: 32
                          sections:
                            description: >-
                              Exact section headings a `glossary`-kind type
                              reads verbatim. Ignored by every other kind.
                            type: array
                            items:
                              description: One exact section heading to read.
                              type: string
                              maxLength: 128
                            maxItems: 64
                          min_doc_count:
                            description: >-
                              Overrides the manifest-level `min_doc_count` for
                              this type.
                            default: 1
                            type: integer
                            minimum: 1
                            maximum: 64
                          format:
                            description: >-
                              Where the artifacts of this type are written —
                              `markdown` a prose file each, `sqlite` rows in the
                              context's structured database.
                            default: markdown
                            x-enum:
                              - markdown
                              - sqlite
                            type: string
                          columns:
                            description: >-
                              Table schema for a `sqlite`-format type. Ignored
                              for `markdown`. Two names that normalize to the
                              same column collide, and the first declaration
                              wins.
                            type: array
                            items:
                              description: One column of the type's table.
                              type: object
                              properties:
                                name:
                                  description: Column name.
                                  type: string
                                  maxLength: 64
                                type:
                                  description: SQLite column affinity.
                                  default: TEXT
                                  x-enum:
                                    - TEXT
                                    - INTEGER
                                    - REAL
                                    - NUMERIC
                                  type: string
                                description:
                                  description: >-
                                    What the column holds. Steers the extraction
                                    that fills it.
                                  type: string
                                  maxLength: 256
                              required:
                                - name
                            maxItems: 64
                          natural_key:
                            description: >-
                              Columns that identify a row uniquely, so
                              re-curating a source upserts its rows rather than
                              duplicating them. `sqlite`-format types only.
                            type: array
                            items:
                              description: One column of the upsert key.
                              type: string
                              maxLength: 64
                            maxItems: 16
                        required:
                          - name
                      maxItems: 32
                    edge_types:
                      description: >-
                        Typed, directed relationships between artifact types,
                        which turn the artifacts into a graph the agent can
                        traverse.
                      type: array
                      items:
                        description: >-
                          One typed, directed relationship between artifact
                          types. `name`, `from`, and `to` are required of a
                          written manifest; a read echoes a stored document that
                          lacks one rather than failing.
                        x-component-name: EdgeType
                        type: object
                        properties:
                          name:
                            description: What the relationship is called, e.g. `mentions`.
                            type: string
                            maxLength: 64
                          from:
                            description: >-
                              Source artifact-type name. May equal `to` for a
                              self-referential edge.
                            type: string
                            maxLength: 64
                          to:
                            description: Target artifact-type name
                            type: string
                            maxLength: 64
                          description:
                            description: >-
                              What the relationship means. Steers the extraction
                              that finds it.
                            type: string
                            maxLength: 512
                          attributes:
                            description: >-
                              Extra properties recorded on each edge, e.g.
                              `count`.
                            type: array
                            items:
                              description: One attribute name.
                              type: string
                              maxLength: 64
                            maxItems: 16
                        required:
                          - name
                          - from
                          - to
                      maxItems: 32
                    min_doc_count:
                      description: >-
                        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.
                      default: 1
                      type: integer
                      minimum: 1
                      maximum: 64
                    max_tokens:
                      description: Output cap for one extracted artifact, in tokens.
                      default: 1500
                      type: integer
                      minimum: 128
                      maximum: 8192
                    max_doc_chars:
                      description: >-
                        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.
                      default: 60000
                      type: integer
                      minimum: 1000
                      maximum: 2000000
                    extraction_window_chars:
                      description: >-
                        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`.
                      default: 0
                      type: integer
                      minimum: 0
                      maximum: 1000000
                    mention_max_chars:
                      description: >-
                        Cap on one recorded mention — what a single document
                        says about the subject — in characters.
                      default: 400
                      type: integer
                      minimum: 100
                      maximum: 4000
                    max_mentions_per_artifact:
                      description: >-
                        How many mentions are fed into the pass that reduces
                        them into one corpus-wide artifact.
                      default: 40
                      type: integer
                      minimum: 1
                      maximum: 500
                    mention_context_chars:
                      description: >-
                        Cap on those mentions once concatenated, in characters.
                        Applied after `max_mentions_per_artifact`.
                      default: 8000
                      type: integer
                      minimum: 1000
                      maximum: 100000
                    max_artifacts_per_type:
                      description: >-
                        How many artifacts one type may produce. Omit for no
                        cap.
                      default: 10000
                      type: integer
                      minimum: 1
                      maximum: 10000
            optimize:
              description: >-
                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.
              x-component-name: OptimizeManifest
              type: object
              properties:
                schedule:
                  description: Cron expression the tuning loop runs on.
                  default: 0 * * * *
                  type: string
                  maxLength: 128
                latency_threshold_ms:
                  description: >-
                    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.
                  default: 60000
                  type: integer
                  minimum: 0
                  maximum: 600000
                min_group_size:
                  description: >-
                    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.
                  default: 2
                  type: integer
                  minimum: 1
                  maximum: 100
                eval_pass_rate_threshold:
                  description: >-
                    Fraction of eval queries a candidate manifest must answer
                    correctly to be considered ready. `1` demands all of them.
                  default: 1
                  type: number
                  format: double
                  minimum: 0
                  maximum: 1
                max_iterations:
                  description: >-
                    How many candidate manifests the loop tries before stopping
                    with its best.
                  default: 20
                  type: integer
                  minimum: 1
                  maximum: 100
            search:
              description: >-
                Standing instructions for the query runtime, pinned on the
                context rather than sent per turn.
              x-component-name: SearchManifest
              type: object
              properties:
                instructions:
                  description: >-
                    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.
                  type: string
    Error:
      description: The error envelope every non-2xx response uses.
      type: object
      properties:
        message:
          description: >-
            Human-readable explanation. Not stable — branch on `code`, not on
            this.
          type: string
        code:
          description: >-
            Stable machine-readable code, present only on errors a client must
            branch on. 
          x-enum:
            - unsupported_api_version
            - preview_not_enabled
            - preview_file_limit
            - preview_byte_limit
            - workspace_host_required
            - workspace_not_found
          type: string
      required:
        - message
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: >-
        Session token from `POST /auth/login`, sent as `Authorization: Bearer
        <token>`.
    apiKey:
      type: apiKey
      in: header
      name: Api-Key
      description: Pinecone API key, accepted as an alternative to the bearer token.

````