> ## 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 complexity analyzer config

> Returns the full complexity analyzer runtime config, including the semantic embedding configuration, the llm fallback classifier configuration, and per-tier reference phrase lists. Returns built-in defaults if none have been configured.



## OpenAPI

````yaml /openapi/openapi.json get /api/routing/complexity-analyzer-config
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)
security:
  - BearerAuth: []
  - BasicAuth: []
  - ApiKeyAuth: []
tags:
  - 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: 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: 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
paths:
  /api/routing/complexity-analyzer-config:
    get:
      tags:
        - Routing
      summary: Get complexity analyzer config
      description: >-
        Returns the full complexity analyzer runtime config, including the
        semantic embedding configuration, the llm fallback classifier
        configuration, and per-tier reference phrase lists. Returns built-in
        defaults if none have been configured.
      operationId: getComplexityAnalyzerConfig
      responses:
        '200':
          description: Complexity analyzer config retrieved successfully
          content:
            application/json:
              schema:
                type: object
                description: Full runtime configuration for complexity routing analysis.
                additionalProperties: false
                required:
                  - keywords
                allOf:
                  - if:
                      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
                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
                  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
                        description: >
                          What answers when semantic classification produces no
                          tier (a match

                          below `min_similarity`, a timeout, or an unfinished
                          warmup). `none`

                          (the default) records the request as skipped. `llm`
                          asks the chat

                          model configured in the analyzer's `llm` block, which
                          is required

                          when this is set.
                  llm:
                    type: object
                    description: >
                      Chat-completion (LLM) fallback classifier settings. The
                      block is inert

                      unless `semantic.fallback` selects `llm`; the classifier
                      runs only after

                      semantic classification produces no tier. 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 fallback
                          classification 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
                      request carries a supported session identity, Bifrost
                      retains the highest tier observed across normally
                      sequential turns for 24 hours of inactivity. Overlapping
                      requests for the same session are best-effort and resolve
                      by last writer wins.
                    additionalProperties: false
                    required:
                      - enabled
                    properties:
                      enabled:
                        type: boolean
                        description: >-
                          Enable monotonic session tier retention. Requires
                          semantic complexity classification; default is false.
        '500':
          description: Internal server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BifrostError'
        '503':
          description: Config store not available
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BifrostError'
      security:
        - ManagementBearerAuth: []
        - BasicAuth: []
components:
  schemas:
    BifrostError:
      type: object
      description: Error response from Bifrost
      properties:
        event_id:
          type: string
        type:
          type: string
        is_bifrost_error:
          type: boolean
        status_code:
          type: integer
        error:
          $ref: '#/components/schemas/ErrorField'
        extra_fields:
          $ref: '#/components/schemas/BifrostErrorExtraFields'
    ErrorField:
      type: object
      properties:
        type:
          type: string
        code:
          type: string
        message:
          type: string
        param:
          type: string
        event_id:
          type: string
    BifrostErrorExtraFields:
      type: object
      properties:
        provider:
          $ref: '#/components/schemas/ModelProvider'
        model_requested:
          type: string
        request_type:
          type: string
    ModelProvider:
      type: string
      description: AI model provider identifier
      enum:
        - anthropic
        - azure
        - bedrock
        - bedrock_mantle
        - cerebras
        - cohere
        - deepseek
        - gemini
        - groq
        - mistral
        - ollama
        - opencode-go
        - opencode-zen
        - openai
        - parasail
        - perplexity
        - sgl
        - vertex
        - openrouter
        - elevenlabs
        - huggingface
        - nebius
        - xai
        - replicate
        - vllm
        - runway
        - runware
        - fireworks
        - sarvam
        - wafer
        - databricks
  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.

````