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

# List Haiqu Algorithms

> List the available quantum algorithms in the catalog.

Use this tool when the user asks any of: "what quantum algorithms can
I run?", "what demos / examples are available?", "show me a quantum
benchmark", or names an algorithm family ("do you have QAOA / VQE /
optimization?").

Returns ALL algorithms in the catalog (not only the runnable ones), each
with a ``runnable`` flag. When picking an algorithm for an actual demo
via ``get_haiqu_algorithm_recipe``, filter to ``runnable=True``; entries
with ``runnable=False`` are roadmap items that have a directory + meta
but no shipped recipe yet.

Match the user's phrasing to a key when they name a family (e.g. "QAOA"
-> "lr-qaoa"). If they ask for a non-runnable algorithm by name, tell
them it's planned but not demo-ready, and offer a runnable alternative.



## OpenAPI

````yaml https://api.haiqu.ai/openapi.json get /ai/qakb/algorithms
openapi: 3.1.0
info:
  title: Haiqu API
  summary: Haiqu RESTful API service.
  description: Cloud service providing the access to Haiqu cloud runtime
  contact:
    name: Haiqu Inc.
    url: https://haiqu.ai/
    email: info@haiqu.ai
  version: 1.4.0
servers: []
security: []
paths:
  /ai/qakb/algorithms:
    get:
      summary: List Haiqu Algorithms
      description: |-
        List the available quantum algorithms in the catalog.

        Use this tool when the user asks any of: "what quantum algorithms can
        I run?", "what demos / examples are available?", "show me a quantum
        benchmark", or names an algorithm family ("do you have QAOA / VQE /
        optimization?").

        Returns ALL algorithms in the catalog (not only the runnable ones), each
        with a ``runnable`` flag. When picking an algorithm for an actual demo
        via ``get_haiqu_algorithm_recipe``, filter to ``runnable=True``; entries
        with ``runnable=False`` are roadmap items that have a directory + meta
        but no shipped recipe yet.

        Match the user's phrasing to a key when they name a family (e.g. "QAOA"
        -> "lr-qaoa"). If they ask for a non-runnable algorithm by name, tell
        them it's planned but not demo-ready, and offer a runnable alternative.
      operationId: list_haiqu_algorithms
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AlgorithmListResponse'
      security:
        - APIKeyQuery: []
        - APIKeyHeader: []
components:
  schemas:
    AlgorithmListResponse:
      properties:
        algorithms:
          items:
            $ref: '#/components/schemas/AlgorithmSummary'
          type: array
          title: Algorithms
      type: object
      required:
        - algorithms
      title: AlgorithmListResponse
      description: Catalog of algorithms an agent can run via get_haiqu_algorithm_recipe.
    AlgorithmSummary:
      properties:
        key:
          type: string
          title: Key
          description: Identifier to pass to get_haiqu_algorithm_recipe, e.g. 'lr-qaoa'.
        status:
          type: string
          title: Status
          description: >-
            Knowledge-base lifecycle status. 'signed_off' means the algorithm
            has been verified end-to-end by KB CI; other values (e.g.
            'reimplemented_baseline_noisy', 'planned') mean the algorithm is on
            the roadmap but not yet at sign-off.
        runnable:
          type: boolean
          title: Runnable
          description: >-
            Whether get_haiqu_algorithm_recipe will return runnable code for
            this key. True only when status='signed_off' AND the algorithm
            declares demo hooks (a spec.yaml recipe: block, or a legacy
            recipe.py). False entries are listed so the catalog stays
            discoverable; the orchestrator should pick a runnable=True entry for
            the demo.
        mode:
          anyOf:
            - type: string
            - type: 'null'
          title: Mode
          description: >-
            How the assembled script is run: 'sampler' scripts submit QASM and
            consume counts; 'estimator' scripts carry a wire-ready 'observable'
            in their MANIFEST to pass verbatim as
            run_circuits_on_qpu_or_simulator's `observables` (with
            run_type='Run' and top-level `shots`), and consume the expectation
            values the job returns. None when the algorithm has no demo hooks
            yet.
        description:
          type: string
          title: Description
          description: >-
            One-line summary of what the algorithm does. For non-runnable
            entries this is the literal placeholder '(no recipe authored yet)'.
      type: object
      required:
        - key
        - status
        - runnable
        - description
      title: AlgorithmSummary
      description: One algorithm entry from the knowledge-base catalog.
      examples:
        - description: >-
            LR-QAOA MaxCut with a linear-ramp schedule; headline metric is the
            approximation ratio.
          key: lr-qaoa
          mode: sampler
          runnable: true
          status: signed_off
        - description: (no recipe authored yet)
          key: shor
          runnable: false
          status: planned
  securitySchemes:
    APIKeyQuery:
      type: apiKey
      in: query
      name: HAIQU_API_KEY
    APIKeyHeader:
      type: apiKey
      in: header
      name: authorization

````