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

# Get model router defaults

> Returns what a new model router starts from, so a client can show it before saving anything - the built-in config with its reference phrases, the decision model's per-tier guidance, and the llm classifier's default prompt.

**Required Permissions**

| Permission | Granted via |
| - | - |
| `Routers:View` | RBAC role or API key scope |

[How permissions work](https://docs.getbifrost.ai/api/procuring-api-keys.md#required-permissions)


## OpenAPI

````yaml /openapi/openapi.json get /api/routing/model-routers/defaults
openapi: 3.1.0
info:
  title: Bifrost API
  description: >
    Bifrost HTTP Transport API for AI model inference and gateway management.


    This API provides a unified interface for interacting with multiple AI
    providers

    including OpenAI, Anthropic, Bedrock, Gemini, and more through a single API,

    along with comprehensive management APIs for configuring and monitoring the
    gateway.


    ## API Structure


    ### Unified Inference API (`/v1/*`)

    The primary API using Bifrost's unified format. Model parameters use the
    format

    `provider/model` (e.g., `openai/gpt-4`, `anthropic/claude-3-opus`).


    ### Async Inference API (`/v1/async/*`)

    Submit inference requests for asynchronous execution. Returns a job ID
    immediately

    and allows polling for results. Supports all inference types except batches,
    files,

    and containers.


    ### Provider Integration APIs

    Native provider-format APIs for drop-in compatibility:

    - `/openai/*` - OpenAI-compatible API

    - `/anthropic/*` - Anthropic-compatible API

    - `/genai/*` - Google GenAI (Gemini) compatible API

    - `/bedrock/*` - AWS Bedrock compatible API

    - `/cohere/*` - Cohere compatible API


    ### Framework Integration APIs

    Multi-provider proxy endpoints for AI frameworks:

    - `/litellm/*` - LiteLLM proxy with all provider formats

    - `/langchain/*` - LangChain compatible endpoints

    - `/pydanticai/*` - PydanticAI compatible endpoints


    ### Management APIs (`/api/*`)

    APIs for managing and monitoring the Bifrost gateway:

    - `/api/config` - Configuration management

    - `/api/providers` - Provider and API key management

    - `/api/plugins` - Plugin management

    - `/api/governance/*` - Virtual keys, teams, customers, budgets, rate
    limits, routing rules, and pricing overrides

    - `/api/logs` - Log search and analytics

    - `/api/mcp/*` - MCP (Model Context Protocol) client management

    - `/api/session/*` - Authentication and session management

    - `/api/cache/*` - Cache management

    - `/health` - Health check endpoint


    ## Fallbacks

    Requests can include fallback models that will be tried if the primary model
    fails.
  version: 1.0.0
  contact:
    name: Contact Us
    url: https://getmaxim.ai/bifrost
  license:
    name: Apache 2.0
    url: https://opensource.org/licenses/Apache-2.0
servers:
  - url: '{baseUrl}'
    description: Your Bifrost instance
    variables:
      baseUrl:
        default: http://localhost:8080
        description: >-
          Base URL of your Bifrost instance (e.g. https://bifrost.mycompany.com,
          or https://mycompany.com/bifrost when served under server.base_path)
security:
  - BearerAuth: []
  - BasicAuth: []
  - ApiKeyAuth: []
tags:
  - name: Agent Gateway
    description: >-
      Agent registrations, A2A protocol calls, push callbacks, and operation
      history
  - name: Models
    description: Model listing and information
  - name: Chat Completions
    description: Chat-based text generation
  - name: Text Completions
    description: Text completion generation
  - name: Responses
    description: OpenAI Responses API compatible endpoints
  - name: OCR
    description: Optical character recognition for documents and images
  - name: Rerank
    description: Document reranking by relevance to a query
  - name: Decisions
    description: Structured decisions evaluated against annotated function-tool definitions
  - name: Embeddings
    description: Text embedding generation
  - name: Images
    description: Image generations, editing, and variations
  - name: Videos
    description: Video generation and management
  - name: Audio
    description: Speech synthesis and transcription
  - name: Count Tokens
    description: Token counting utilities
  - name: Batch
    description: Batch processing operations
  - name: Files
    description: File management operations
  - name: Containers
    description: Container management operations
  - name: Async Jobs
    description: Asynchronous job submission and retrieval endpoints
  - name: Realtime
    description: Realtime WebSocket and WebRTC endpoints
  - name: OpenAI Integration
    description: OpenAI-compatible API endpoints (/openai/*)
  - name: Azure Integration
    description: Azure OpenAI integration endpoints
  - name: Anthropic Integration
    description: Anthropic-compatible API endpoints (/anthropic/*)
  - name: GenAI Integration
    description: Google GenAI (Gemini) compatible API endpoints (/genai/*)
  - name: Bedrock Integration
    description: AWS Bedrock compatible API endpoints (/bedrock/*)
  - name: Cohere Integration
    description: Cohere compatible API endpoints (/cohere/*)
  - name: Typesafe Integration
    description: Typesafe compatible API endpoints (/typesafe/*)
  - name: LiteLLM Integration
    description: LiteLLM proxy endpoints with multi-provider support (/litellm/*)
  - name: LangChain Integration
    description: LangChain compatible endpoints with multi-provider support (/langchain/*)
  - name: PydanticAI Integration
    description: >-
      PydanticAI compatible endpoints with multi-provider support
      (/pydanticai/*)
  - name: Health
    description: Health check endpoints
  - name: Configuration
    description: Configuration management endpoints
  - name: Session
    description: Session and authentication endpoints
  - name: Providers
    description: Provider management endpoints
  - name: Plugins
    description: Plugin management endpoints
  - name: MCP
    description: Model Context Protocol endpoints
  - name: Governance
    description: Virtual keys, teams, and customers management
  - name: Routing
    description: Routing rules and complexity analyzer configuration
  - name: Logging
    description: Log search and management endpoints
  - name: Cache
    description: Cache management endpoints
  - name: Vault
    description: Vault secret management endpoints
  - name: Skills
    description: Skills Repository management, marketplace, and download endpoints
  - name: Audit Logs
    description: >-
      CADF-compliant audit log search, export, and signature verification
      endpoints
  - name: Webhooks
    description: Webhook endpoint management and signed async-job delivery history
  - name: Notifications
    description: >-
      Role-targeted dashboard notifications, delivered over the dashboard
      WebSocket
  - name: News Feeds
    description: >-
      RSS and Atom news sources shown in the News tab of the dashboard
      notification tray
  - name: Background Jobs
    description: >-
      Status, progress and cancellation of durable background jobs (cost
      recalculation, Warp log indexing, and others)
  - name: Warp
    description: >-
      Configuration for Warp, the dashboard agent that answers questions about
      the deployment's own telemetry
  - name: Relays
    description: >-
      Relays to non-LLM HTTP APIs - endpoint management, usage preview, Relay
      Logs and the /relay data plane
paths:
  /api/routing/model-routers/defaults:
    get:
      tags:
        - Routing
      summary: Get model router defaults
      description: >-
        Returns what a new model router starts from, so a client can show it
        before saving anything - the built-in config with its reference phrases,
        the decision model's per-tier guidance, and the llm classifier's default
        prompt.
      operationId: getModelRouterDefaults
      responses:
        '200':
          description: Model router defaults retrieved successfully
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ModelRouterDefaults'
      security:
        - ManagementBearerAuth: []
        - BasicAuth: []
components:
  schemas:
    ModelRouterDefaults:
      type: object
      description: What a new model router starts from.
      properties:
        config:
          type: object
          description: Full runtime configuration for complexity routing analysis.
          additionalProperties: false
          required:
            - keywords
          allOf:
            - if:
                not:
                  required:
                    - classifier
                  properties:
                    classifier:
                      enum:
                        - decision
                        - llm
                properties:
                  session:
                    properties:
                      enabled:
                        const: true
                    required:
                      - enabled
                required:
                  - session
              then:
                required:
                  - semantic
            - if:
                properties:
                  semantic:
                    properties:
                      fallback:
                        const: llm
                    required:
                      - fallback
                required:
                  - semantic
              then:
                required:
                  - llm
            - if:
                properties:
                  classifier:
                    const: llm
                required:
                  - classifier
              then:
                required:
                  - llm
          properties:
            tier_boundaries:
              type: object
              deprecated: true
              description: >
                Deprecated score thresholds for the retired lexical complexity
                classifier.

                This block is optional and ignored by semantic classification,
                but remains

                accepted for backward compatibility. When supplied, values must
                satisfy

                0 < simple_medium < medium_complex < 1.
              additionalProperties: false
              required:
                - simple_medium
                - medium_complex
              properties:
                simple_medium:
                  type: number
                  deprecated: true
                  description: >-
                    Deprecated score boundary between SIMPLE and MEDIUM tiers
                    (ignored by semantic classification)
                  exclusiveMinimum: 0
                  exclusiveMaximum: 1
                medium_complex:
                  type: number
                  deprecated: true
                  description: >-
                    Deprecated score boundary between MEDIUM and COMPLEX tiers
                    (ignored by semantic classification)
                  exclusiveMinimum: 0
                  exclusiveMaximum: 1
            keywords:
              type: object
              description: >
                Reference phrases for semantic complexity classification, one
                list per tier.

                Each request is embedded and takes the tier of its nearest
                phrase. Entries

                should be whole example prompts rather than individual keywords.
                Each phrase

                is limited to 2000 characters, the normalized lists may contain
                at most 750

                phrases combined, and the same phrase cannot appear in two
                tiers. The field

                names predate semantic classification and are kept for backward
                compatibility.
              additionalProperties: false
              required:
                - simple_keywords
                - medium_keywords
                - complex_keywords
              properties:
                simple_keywords:
                  type: array
                  description: Reference phrases for the SIMPLE tier (50 built-in defaults)
                  items:
                    type: string
                    maxLength: 2000
                  minItems: 1
                medium_keywords:
                  type: array
                  description: Reference phrases for the MEDIUM tier (50 built-in defaults)
                  items:
                    type: string
                    maxLength: 2000
                  minItems: 1
                complex_keywords:
                  type: array
                  description: >-
                    Reference phrases for the COMPLEX tier (50 built-in
                    defaults)
                  items:
                    type: string
                    maxLength: 2000
                  minItems: 1
            classifier:
              type: string
              enum:
                - semantic
                - decision
                - llm
              default: semantic
              description: >-
                Primary complexity classifier; omitted configuration keeps the
                semantic default. llm classifies with the model in the llm
                block.
            semantic:
              type: object
              description: >
                Embedding configuration for semantic complexity classification.
                When absent,

                no complexity tier is published and rules referencing
                complexity_tier fall

                through. The provider must have an enabled key.
              additionalProperties: false
              required:
                - provider
                - embedding_model
              properties:
                provider:
                  type: string
                  minLength: 1
                  description: Provider used for embedding calls (must have an enabled key)
                embedding_model:
                  type: string
                  minLength: 1
                  description: Embedding model, e.g. text-embedding-3-small
                timeout:
                  description: >-
                    Ceiling on the inline embedding call. Accepts a duration
                    string ("1.5s") or milliseconds as a number. Default 1.5s;
                    exceeding it publishes no tier for that request.
                  oneOf:
                    - type: string
                      pattern: ^[0-9]+(\.[0-9]+)?(ns|us|µs|ms|s|m|h)$
                    - type: number
                      exclusiveMinimum: 0
                min_similarity:
                  type: number
                  minimum: 0
                  exclusiveMaximum: 1
                  description: >-
                    Similarity floor for the nearest reference phrase; below it
                    no tier is published. 0 (default) accepts the nearest
                    eligible match. Compared against the vector store backend's
                    own similarity scale (raw cosine for
                    chromem/Qdrant/Pinecone/Redis, certainty for Weaviate).
                message_history_count:
                  type: integer
                  minimum: 1
                  maximum: 10
                  description: >-
                    Number of recent user messages joined oldest-first into the
                    embedded text. 1 (default) embeds only the latest message.
                    System prompts and assistant replies are never embedded.
                count_toward_budgets:
                  type: boolean
                  description: >-
                    Whether embedding usage counts toward virtual-key budgets
                    (default false)
                vector_store:
                  type: string
                  enum:
                    - embedded
                    - vector_store
                  description: >
                    Where reference-phrase embeddings live. `embedded` (default)
                    uses the

                    built-in in-memory store, so phrases are re-embedded on
                    every restart.

                    `vector_store` uses the top-level `vector_store` when one is
                    configured

                    and falls back to the embedded store otherwise.
                fallback:
                  type: string
                  enum:
                    - none
                    - llm
                    - decision
                  description: >
                    What answers when semantic classification produces no tier.
                    `none`

                    (the default) records the request as skipped, `llm` uses the
                    configured

                    chat model, and `decision` uses the configured decision
                    model.
            decision:
              type: object
              description: >-
                Decision-model complexity-classifier request settings.
                Credentials come from the selected provider's configuration.
              additionalProperties: false
              properties:
                provider:
                  type: string
                  description: >-
                    Provider serving the decision model, e.g. `typesafe`,
                    `cloudflare` (Clef), or a custom provider with
                    `base_provider_type` `typesafe` (Laya, Nimble). Set together
                    with `model`; leave both empty for `typesafe`/`jev-latest`.
                model:
                  type: string
                  description: >-
                    Decision model on that provider, e.g. `jev-latest`,
                    `@cf/cloudflare/clef-flash`, `nimble-latest`, `english`. Set
                    together with `provider`; leave both empty for
                    `typesafe`/`jev-latest`.
                previous_message_count:
                  type: integer
                  minimum: 0
                  maximum: 5
                  default: 1
                  description: >-
                    Number of preceding user messages sent with the current user
                    request. Assistant messages are excluded.
                timeout:
                  description: >-
                    Maximum decision-model classification latency. Accepts a
                    duration string or milliseconds as a number; default 1500ms.
                  oneOf:
                    - type: string
                      pattern: ^[0-9]+(\.[0-9]+)?(ns|us|µs|ms|s|m|h)$
                    - type: number
                      minimum: 0
                min_confidence:
                  type: number
                  minimum: 0
                  maximum: 1
                  default: 0
                  description: >-
                    Confidence an answer must reach to publish its tier. An
                    answer below it publishes no tier. A missing confidence is
                    derived from the tier probabilities; an answer with neither
                    is kept. 0 keeps every answer.
                criteria:
                  type: object
                  description: >-
                    Per-tier overrides of the shipped decision-model
                    definitions, signals, and examples. Any tier or field left
                    out sends the default.
                  additionalProperties: false
                  properties:
                    SIMPLE:
                      type: object
                      additionalProperties: false
                      properties:
                        definition:
                          type: string
                          maxLength: 500
                          description: >-
                            Replaces this tier's shipped definition. Omit to use
                            the default.
                        signals:
                          type: array
                          maxItems: 12
                          items:
                            type: string
                            maxLength: 300
                          description: >-
                            Replaces this tier's shipped signals. Omit to use
                            the default.
                        examples:
                          type: array
                          maxItems: 12
                          items:
                            type: string
                            maxLength: 300
                          description: >-
                            Replaces this tier's shipped examples. Omit to use
                            the default.
                    MEDIUM:
                      type: object
                      additionalProperties: false
                      properties:
                        definition:
                          type: string
                          maxLength: 500
                          description: >-
                            Replaces this tier's shipped definition. Omit to use
                            the default.
                        signals:
                          type: array
                          maxItems: 12
                          items:
                            type: string
                            maxLength: 300
                          description: >-
                            Replaces this tier's shipped signals. Omit to use
                            the default.
                        examples:
                          type: array
                          maxItems: 12
                          items:
                            type: string
                            maxLength: 300
                          description: >-
                            Replaces this tier's shipped examples. Omit to use
                            the default.
                    COMPLEX:
                      type: object
                      additionalProperties: false
                      properties:
                        definition:
                          type: string
                          maxLength: 500
                          description: >-
                            Replaces this tier's shipped definition. Omit to use
                            the default.
                        signals:
                          type: array
                          maxItems: 12
                          items:
                            type: string
                            maxLength: 300
                          description: >-
                            Replaces this tier's shipped signals. Omit to use
                            the default.
                        examples:
                          type: array
                          maxItems: 12
                          items:
                            type: string
                            maxLength: 300
                          description: >-
                            Replaces this tier's shipped examples. Omit to use
                            the default.
            llm:
              type: object
              description: >
                Chat-completion (LLM) classifier settings. Used as the primary
                classifier

                when `classifier` is `llm`, and as the fallback when
                `semantic.fallback`

                selects `llm`, where it runs only after semantic classification
                produces no

                tier. Otherwise the block is kept but not used. Tier names
                (SIMPLE, MEDIUM,

                COMPLEX) and the response format are fixed: the gateway always
                appends a

                non-editable reinforcement stating them.
              additionalProperties: false
              required:
                - provider
                - model
              properties:
                provider:
                  type: string
                  minLength: 1
                  description: >-
                    Provider used to run the classification chat completion
                    (must have an enabled key)
                model:
                  type: string
                  minLength: 1
                  description: >-
                    Chat model asked to name the tier. Every classification it
                    makes waits on one completion from this model, so pick a
                    small, fast one.
                timeout:
                  description: >-
                    Per-request classification timeout. Accepts a duration
                    string ("2s") or milliseconds as a number. Default 4s. On
                    timeout no complexity tier is published and the request is
                    recorded as skipped.
                  oneOf:
                    - type: string
                      pattern: ^[0-9]+(\.[0-9]+)?(ns|us|µs|ms|s|m|h)$
                    - type: number
                      exclusiveMinimum: 0
                prompt:
                  type: string
                  maxLength: 4000
                  description: >-
                    Replaces the shipped classification guidance (max 4000
                    characters); empty means the shipped guidance is used. The
                    tier-name and response-format reinforcement is appended by
                    the gateway either way and cannot be edited.
                message_history_count:
                  type: integer
                  minimum: 1
                  maximum: 10
                  description: >-
                    How many of the most recent user messages are given to the
                    classifier, oldest first (default 1, the latest message
                    only). Only user turns count; system prompts and assistant
                    replies are never sent.
                count_toward_budgets:
                  type: boolean
                  description: >-
                    Whether classification completion cost counts toward
                    virtual-key budgets (record-only, never enforced; default
                    false)
            session:
              type: object
              description: >-
                Session-aware complexity routing. When enabled and a supported
                session identity is present, Bifrost retains the highest tier
                observed across normally sequential turns for 24 hours of
                inactivity. It uses the configured primary classifier and is
                independent of provider session stickiness.
              additionalProperties: false
              required:
                - enabled
              properties:
                enabled:
                  type: boolean
                  description: Enable monotonic session tier retention; default is false.
        decision_defaults:
          type: object
          description: >-
            The decision model's shipped per-tier guidance, as the router status
            endpoint serves it.
          properties:
            criteria:
              type: object
              description: >-
                Each tier's shipped definition, signals and examples, keyed by
                tier (SIMPLE, MEDIUM, COMPLEX).
              additionalProperties:
                type: object
                properties:
                  definition:
                    type: string
                  signals:
                    type: array
                    items:
                      type: string
                  examples:
                    type: array
                    items:
                      type: string
        llm_default_prompt:
          type: string
          description: The llm classifier's shipped classification prompt.
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: >
        Bearer token authentication. Use your provider API key or Bifrost
        authentication token.

        Virtual keys (prefixed with `sk-bf-`) can also be passed here.
    BasicAuth:
      type: http
      scheme: basic
      description: >
        Basic authentication using the Bifrost admin username and password

        (`auth_config.admin_username` / `auth_config.admin_password`).

        Accepted on management APIs (`/api/*`, `/metrics`, `/ws`) only - the
        inference

        middleware never validates Basic credentials.
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: |
        API key authentication via the `x-api-key` header.
        Virtual keys (prefixed with `sk-bf-`) can also be passed here.
    ManagementBearerAuth:
      type: http
      scheme: bearer
      description: >
        Management API authentication for `/api/*` endpoints. Use the
        `Authorization` header

        with `Bearer <token>`, where `<token>` is one of:


        - a Bifrost management API key,

        - a dashboard session token issued by `POST /api/session/login`,

        - base64 of `<admin-username>:<admin-password>` (legacy equivalent of
        `BasicAuth`).


        Virtual keys (`sk-bf-*`) and the `x-api-key` header are not accepted on
        management APIs -

        the sole exception is `GET /api/governance/virtual-keys/quota`, which is
        virtual-key-only.


        Authentication alone is not sufficient in Bifrost Enterprise: each
        operation page shows a

        **Required Permissions** table (`Resource:Operation`, for example
        `Dashboard:View`) above

        its Authorizations section, and the caller's RBAC role or management API
        key scopes must

        include what it lists, otherwise the request is rejected with `403
        Forbidden`.


        A local admin — authenticated with the admin password, or any caller on
        a deployment with

        dashboard auth disabled — bypasses these checks and can call every
        management endpoint.


        **OSS setup lock.** On Bifrost OSS, while dashboard auth is not active
        (no admin account,

        or auth disabled), every management endpoint except the public ones
        (`/health`,

        `/api/version`, `/api/session/is-auth-enabled`, `/api/session/login`,
        ...) requires the

        operator's setup token in the `X-Bifrost-Setup-Token` header, in place
        of `Authorization`.

        The token is set with `setup_token` in `config.json` or the
        `BIFROST_SETUP_TOKEN`

        environment variable. A missing header returns `401`, a wrong token
        `403`. The header

        stops working once dashboard auth is enabled. The dashboard instead
        trades the token once

        for an HttpOnly `bifrost_setup_session` cookie via `POST
        /api/session/setup`.

        See [Required permissions](/api/procuring-api-keys#required-permissions)
        for how

        permissions are derived and which endpoints are exempt.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.