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

# MiniMax-M3 - OpenAI-kompatible API

> - Verwenden Sie das OpenAI Chat Completions-Protokoll, um das MiniMax-M3 Modell aufzurufen
- **Mehrrundengespräch**: Unterstützt Einzelrunden- oder Mehrrundenkontext-Dialog
- **System-Prompts**: Passen Sie Rolle und Verhalten der KI über `role=system`-Nachrichten an
- **Multimodale Eingabe**: `content` unterstützt gemischten Text + Bild / Video
- **Denkmodus**: Wird über `thinking.type` gesteuert; der Denkinhalt wird über `reasoning_content` zurückgegeben
- **Streaming-Ausgabe**: Unterstützt SSE-Streaming-Antworten
- **Werkzeugaufrufe**: Unterstützt Function Calling

<Note>
  **BaseURL**: Die Standard-BaseURL ist `https://direct.evolink.ai`, die Textmodelle und langlebige Verbindungen besser unterstützt. `https://api.evolink.ai` ist der primäre Endpunkt für multimodale Dienste und dient als Ausweichadresse für Textmodelle.
</Note>


## OpenAPI

````yaml de/api-manual/language-series/minimax-m3/minimax-m3-chat.json POST /v1/chat/completions
openapi: 3.1.0
info:
  title: MiniMax-M3 Vollständige API-Referenz (OpenAI-kompatibel)
  description: >-
    Vollständige API-Referenz für die MiniMax-M3 Chat-Schnittstelle.


    **Modellfähigkeiten**:

    - Maximale Ausgabe: **524.288 Tokens** (512K), empfohlen **131.072 Tokens**
    (128K)

    - Denkmodus: Wird über das Feld `thinking` gesteuert, Standardwert
    `adaptive` (das Modell entscheidet adaptiv, ob tiefes Nachdenken eingesetzt
    wird)

    - Multimodale Eingabe: Unterstützt Text, Bilder und Video

    - Werkzeugaufrufe: Unterstützt Function Calling

    - Streaming-Ausgabe: Unterstützt SSE-Streaming-Antworten
  license:
    name: MIT
  version: 1.0.0
servers:
  - url: https://direct.evolink.ai
    description: Produktion (empfohlen)
  - url: https://api.evolink.ai
    description: Alternative URL
security:
  - bearerAuth: []
tags:
  - name: Chat-Vervollständigung
    description: Endpunkte für KI-Chat-Vervollständigung
paths:
  /v1/chat/completions:
    post:
      tags:
        - Chat-Vervollständigung
      summary: MiniMax-M3 Chat-Schnittstelle (OpenAI-kompatibel)
      description: >-
        - Verwenden Sie das OpenAI Chat Completions-Protokoll, um das MiniMax-M3
        Modell aufzurufen

        - **Mehrrundengespräch**: Unterstützt Einzelrunden- oder
        Mehrrundenkontext-Dialog

        - **System-Prompts**: Passen Sie Rolle und Verhalten der KI über
        `role=system`-Nachrichten an

        - **Multimodale Eingabe**: `content` unterstützt gemischten Text + Bild
        / Video

        - **Denkmodus**: Wird über `thinking.type` gesteuert; der Denkinhalt
        wird über `reasoning_content` zurückgegeben

        - **Streaming-Ausgabe**: Unterstützt SSE-Streaming-Antworten

        - **Werkzeugaufrufe**: Unterstützt Function Calling
      operationId: createChatCompletionMiniMaxM3
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ChatCompletionRequest'
            examples:
              simple_text:
                summary: Einzelrunden-Textkonversation
                value:
                  model: MiniMax-M3
                  messages:
                    - role: user
                      content: Bitte stelle dich vor
              multi_turn:
                summary: Mehrrundengespräch (Kontextverständnis)
                value:
                  model: MiniMax-M3
                  messages:
                    - role: user
                      content: Was ist Python?
                    - role: assistant
                      content: Python ist eine höhere Programmiersprache...
                    - role: user
                      content: Welche Vorteile hat es?
              system_prompt:
                summary: System-Prompts verwenden
                value:
                  model: MiniMax-M3
                  messages:
                    - role: system
                      content: >-
                        Du bist ein professioneller Python-Programmierassistent.
                        Beantworte Fragen knapp.
                    - role: user
                      content: Wie liest man eine Datei ein?
              image_understanding:
                summary: Bildverständnis (multimodale Eingabe)
                value:
                  model: MiniMax-M3
                  thinking:
                    type: adaptive
                  messages:
                    - role: user
                      content:
                        - type: text
                          text: Was ist auf diesem Bild zu sehen?
                        - type: image_url
                          image_url:
                            url: https://example.com/image.jpeg
                  max_completion_tokens: 500
              disable_thinking:
                summary: Denkmodus deaktivieren (direkte Antwort)
                value:
                  model: MiniMax-M3
                  thinking:
                    type: disabled
                  messages:
                    - role: user
                      content: Was ist die Hauptstadt von Frankreich?
              tool_calling:
                summary: Function Calling (Werkzeugaufruf)
                value:
                  model: MiniMax-M3
                  messages:
                    - role: user
                      content: Prüfe das heutige Wetter in Peking
                  tools:
                    - type: function
                      function:
                        name: get_weather
                        description: Wetterbedingungen für eine angegebene Stadt abfragen
                        parameters:
                          type: object
                          properties:
                            location:
                              type: string
                              description: 'Stadtname, z. B.: Peking'
                          required:
                            - location
              streaming:
                summary: Streaming-Ausgabe
                value:
                  model: MiniMax-M3
                  stream: true
                  stream_options:
                    include_usage: true
                  messages:
                    - role: user
                      content: Schreibe ein kurzes Gedicht über den Frühling
      responses:
        '200':
          description: Chat-Vervollständigung erfolgreich
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ChatCompletionResponse'
              examples:
                default_thinking:
                  summary: >-
                    Standard (Denkinhalt inline in content innerhalb von
                    <think>-Tags)
                  value:
                    id: 066b36619b147e326d17053cccdef70f
                    choices:
                      - finish_reason: stop
                        index: 0
                        message:
                          content: >-
                            <think>

                            Der Benutzer fragt nach der Hauptstadt von
                            Frankreich, was eine Allgemeinwissensfrage ist. Die
                            Antwort lautet Paris.

                            </think>

                            Die Hauptstadt von Frankreich ist **Paris**.
                          role: assistant
                          name: MiniMax AI
                          audio_content: ''
                    created: 1777026807
                    model: MiniMax-M3
                    object: chat.completion
                    usage:
                      total_tokens: 60
                      total_characters: 0
                      prompt_tokens: 7
                      completion_tokens: 53
                      prompt_tokens_details:
                        cached_tokens: 0
                    input_sensitive: false
                    output_sensitive: false
                    input_sensitive_type: 0
                    output_sensitive_type: 0
                    base_resp:
                      status_code: 0
                      status_msg: ''
                tool_calls:
                  summary: Werkzeugaufruf ausgelöst (finish_reason=tool_calls)
                  value:
                    id: 066b13db03518f86c2e3c9b073c04272
                    choices:
                      - finish_reason: tool_calls
                        index: 0
                        message:
                          content: >-
                            <think>

                            Der Benutzer möchte das Wetter in Peking abfragen
                            und ruft das get_weather-Werkzeug auf.

                            </think>

                            Ich prüfe für dich das aktuelle Wetter in Peking.
                          role: assistant
                          name: MiniMax AI
                          tool_calls:
                            - id: call_function_p4iiqtpnh5bj_1
                              type: function
                              function:
                                name: get_weather
                                arguments: '{"location": "Peking"}'
                              index: 0
                          audio_content: ''
                    created: 1777026900
                    model: MiniMax-M3
                    object: chat.completion
                    usage:
                      total_tokens: 110
                      total_characters: 0
                      prompt_tokens: 86
                      completion_tokens: 24
                      prompt_tokens_details:
                        cached_tokens: 0
                    input_sensitive: false
                    output_sensitive: false
                    input_sensitive_type: 0
                    output_sensitive_type: 0
                    base_resp:
                      status_code: 0
                      status_msg: ''
        '400':
          description: Ungültige Anfrageparameter
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 400
                  message: Invalid request parameters
                  type: invalid_request_error
        '401':
          description: Nicht authentifiziert, Token ungültig oder abgelaufen
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 401
                  message: Invalid or expired token
                  type: authentication_error
        '402':
          description: Kontingent unzureichend, Aufladung erforderlich
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 402
                  message: Insufficient quota
                  type: insufficient_quota_error
        '403':
          description: Zugriff auf dieses Modell verweigert
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 403
                  message: Access denied for this model
                  type: permission_error
                  param: model
        '404':
          description: Ressource nicht gefunden
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 404
                  message: Specified model not found
                  type: not_found_error
                  param: model
        '413':
          description: Anfragetext zu groß
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 413
                  message: Request body too large
                  type: request_too_large_error
                  param: messages
        '429':
          description: Anfragelimit überschritten
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 429
                  message: Rate limit exceeded
                  type: rate_limit_error
        '500':
          description: Interner Serverfehler
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 500
                  message: Internal server error
                  type: internal_server_error
        '502':
          description: Bad Gateway
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 502
                  message: Bad gateway
                  type: bad_gateway_error
        '503':
          description: Dienst vorübergehend nicht verfügbar
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 503
                  message: Service temporarily unavailable
                  type: service_unavailable_error
components:
  schemas:
    ChatCompletionRequest:
      type: object
      required:
        - model
        - messages
      properties:
        model:
          type: string
          description: Name des Chat-Modells
          enum:
            - MiniMax-M3
          example: MiniMax-M3
        messages:
          type: array
          description: >-
            Liste der Konversationsnachrichten, unterstützt Mehrrundendialog


            Nachrichten mit unterschiedlichen Rollen haben unterschiedliche
            Feldstrukturen; wählen Sie die entsprechende Rolle zur Ansicht aus
          items:
            oneOf:
              - $ref: '#/components/schemas/SystemMessage'
              - $ref: '#/components/schemas/UserMessage'
              - $ref: '#/components/schemas/AssistantRequestMessage'
              - $ref: '#/components/schemas/ToolMessage'
            discriminator:
              propertyName: role
              mapping:
                system:
                  $ref: '#/components/schemas/SystemMessage'
                user:
                  $ref: '#/components/schemas/UserMessage'
                assistant:
                  $ref: '#/components/schemas/AssistantRequestMessage'
                tool:
                  $ref: '#/components/schemas/ToolMessage'
          minItems: 1
        thinking:
          type: object
          description: >-
            Steuert tiefes Nachdenken


            **Hinweise**:

            - **Standardwert `adaptive`**: Das Modell entscheidet adaptiv anhand
            der Schwierigkeit des Problems, ob tiefes Nachdenken eingesetzt wird

            - Standardmäßig wird der Denkinhalt inline in das Antwort-`content`
            eingebettet (umschlossen von `<think>...</think>`-Tags); um ihn in
            ein eigenes Feld auszulagern, verwenden Sie `reasoning_split`
          properties:
            type:
              type: string
              description: >-
                Modus für tiefes Nachdenken


                - `adaptive`: Das Modell entscheidet selbstständig, ob
                Nachdenken erforderlich ist (empfohlener Standardwert)

                - `disabled`: Nachdenken deaktivieren, direkt antworten
              enum:
                - disabled
                - adaptive
              default: adaptive
        reasoning_split:
          type: boolean
          description: >-
            Ob der Denkinhalt in ein separates Feld ausgelagert wird


            - `false` (Standard): Der Denkinhalt wird inline in `content`
            eingebettet, umschlossen von `<think>...</think>`-Tags

            - `true`: Der Denkinhalt wird in
            `choices[].message.reasoning_content` und `reasoning_details`
            ausgelagert
        temperature:
          type: number
          description: >-
            Sampling-Temperatur, steuert die Zufälligkeit der Ausgabe


            **Hinweise**:

            - Niedrigere Werte (z. B. 0,2): Deterministischere, fokussiertere
            Ausgabe

            - Höhere Werte (z. B. 1,5): Zufälligere, kreativere Ausgabe

            - Bereich: `[0, 2]`, Standard 1
          minimum: 0
          maximum: 2
          default: 1
          example: 1
        top_p:
          type: number
          description: >-
            Nucleus-Sampling-Parameter


            **Hinweise**:

            - Steuert das Sampling aus Tokens mit kumulativer Wahrscheinlichkeit

            - z. B. 0,95 bedeutet die Auswahl aus Tokens, die 95 % kumulative
            Wahrscheinlichkeit erreichen

            - Bereich: `[0, 1]`, MiniMax-M3 Standard 0,95


            **Empfehlung**: Passen Sie temperature und top_p nicht gleichzeitig
            an
          minimum: 0
          maximum: 1
          default: 0.95
          example: 0.95
        max_completion_tokens:
          type: integer
          description: >-
            Obergrenze für die Länge des generierten Inhalts (in Tokens)


            **Hinweise**:

            - MiniMax-M3 empfohlen **131.072** (128K), maximal **524.288**
            (512K)

            - Vom Nachdenken erzeugte Tokens zählen ebenfalls zu dieser Grenze

            - Wenn die Generierung aufgrund von `length` unterbrochen wird,
            versuchen Sie, diesen Wert zu erhöhen
          minimum: 1
          maximum: 524288
          example: 131072
        stream:
          type: boolean
          description: >-
            Ob die Antwort im Streaming-Modus zurückgegeben wird


            - `true`: Streaming-Antwort, gibt Inhalte in Echtzeit-Chunks über
            SSE (Server-Sent Events) zurück

            - `false`: Wartet auf die vollständige Antwort, bevor sie
            zurückgegeben wird (Standard)
          default: false
          example: false
        stream_options:
          type: object
          description: |-
            Optionen für die Streaming-Antwort

            Nur wirksam, wenn `stream=true`
          properties:
            include_usage:
              type: boolean
              description: >-
                Gibt am Ende des Streams einen zusätzlichen Chunk zurück, der
                nur `usage`-Statistiken enthält
        tools:
          type: array
          description: >-
            Liste der Werkzeugdefinitionen für Function Calling


            Jedes Werkzeug benötigt einen Namen, eine Beschreibung und ein
            Parameterschema
          items:
            $ref: '#/components/schemas/Tool'
        max_tokens:
          type: integer
          description: >-
            Veralteter Parameter zur Begrenzung der Generierungslänge


            **Hinweis**: Veraltet, bitte verwenden Sie stattdessen
            `max_completion_tokens`
          deprecated: true
          minimum: 1
    ChatCompletionResponse:
      type: object
      properties:
        id:
          type: string
          description: Eindeutige Kennung für die Chat-Vervollständigung
          example: 0668a381bdc3c0ded310e27c9a46d16e7
        model:
          type: string
          description: Tatsächlich verwendeter Modellname
          example: MiniMax-M3
        object:
          type: string
          enum:
            - chat.completion
          description: Antworttyp
          example: chat.completion
        created:
          type: integer
          description: Erstellungszeitstempel (Unix-Sekunden)
          example: 1777026807
        choices:
          type: array
          description: Liste der Chat-Vervollständigungsoptionen
          items:
            $ref: '#/components/schemas/Choice'
        usage:
          $ref: '#/components/schemas/Usage'
        input_sensitive:
          type: boolean
          description: >-
            Ob der Eingabeinhalt einen Filter für sensible Wörter ausgelöst hat.
            Wenn die Eingabe schwerwiegend gegen die Richtlinien verstößt, gibt
            die API einen Inhaltsverstoßfehler mit leerem Antwortinhalt zurück
        input_sensitive_type:
          type: integer
          description: >-
            Art des durch die Eingabe ausgelösten sensiblen Worts (wird
            zurückgegeben, wenn `input_sensitive` true ist): 1 schwerer Verstoß;
            2 Pornografie; 3 Werbung; 4 verbotener Inhalt; 5 beleidigende
            Sprache; 6 Gewalt/Terrorismus; 7 Sonstiges
        output_sensitive:
          type: boolean
          description: Ob der Ausgabeinhalt einen Filter für sensible Wörter ausgelöst hat
        output_sensitive_type:
          type: integer
          description: Art des durch die Ausgabe ausgelösten sensiblen Worts
        base_resp:
          type: object
          description: Statuscode und Fehlerdetails
          properties:
            status_code:
              type: integer
              description: >-
                Statuscode. `0` bedeutet Erfolg; andere Codes umfassen `1002`
                für Ratenbegrenzung, `1008` für unzureichendes Guthaben, `1039`
                für Überschreitung des Token-Limits, `2013` für Parameterfehler
                usw.
            status_msg:
              type: string
              description: Fehlerdetails
    ErrorResponse:
      type: object
      properties:
        error:
          type: object
          properties:
            code:
              type: integer
              description: HTTP-Statusfehlercode
            message:
              type: string
              description: Fehlerbeschreibung
            type:
              type: string
              description: Fehlertyp
            param:
              type: string
              description: Name des zugehörigen Parameters
    SystemMessage:
      title: System Message
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - system
          description: Rollenkennung, fest auf `system` gesetzt
        content:
          type: string
          description: >-
            Inhalt des System-Prompts, dient zum Festlegen der Rolle und des
            Verhaltens der KI
        name:
          type: string
          description: >-
            Name des Teilnehmers, dient zur Unterscheidung verschiedener Quellen
            von System-Prompts
    UserMessage:
      title: User Message
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - user
          description: Rollenkennung, fest auf `user` gesetzt
        content:
          description: >-
            Inhalt der Benutzernachricht


            **Hinweise**:

            - Für reinen Text übergeben Sie direkt eine Zeichenkette

            - Für Multimodalität übergeben Sie ein Content-Part-Array, das
            `text` / `image_url` (Bilder, Video) unterstützt
          oneOf:
            - type: string
            - type: array
              items:
                $ref: '#/components/schemas/ContentPart'
        name:
          type: string
          description: >-
            Name des Teilnehmers, dient zur Unterscheidung verschiedener
            Benutzer
    AssistantRequestMessage:
      title: Assistant Message
      type: object
      required:
        - role
      properties:
        role:
          type: string
          enum:
            - assistant
          description: Rollenkennung, fest auf `assistant` gesetzt
        content:
          type:
            - string
            - 'null'
          description: >-
            Inhalt der Assistentennachricht


            **Hinweise**:

            - Dient zum Übergeben historischer Assistentenantworten in
            Mehrrundengesprächen

            - Kann `null` sein, wenn `tool_calls` vorhanden ist
        name:
          type: string
          description: Name des Teilnehmers
        tool_calls:
          type: array
          description: >-
            Liste der Werkzeugaufrufe


            Dient zum Übergeben historischer Werkzeugaufruf-Informationen in
            Mehrrundengesprächen
          items:
            type: object
            properties:
              id:
                type: string
                description: Eindeutige Kennung für den Werkzeugaufruf
              type:
                type: string
                enum:
                  - function
              function:
                type: object
                properties:
                  name:
                    type: string
                    description: Name der aufgerufenen Funktion
                  arguments:
                    type: string
                    description: Funktionsargumente (JSON-Zeichenkette)
    ToolMessage:
      title: Tool Message
      type: object
      required:
        - role
        - content
        - tool_call_id
      properties:
        role:
          type: string
          enum:
            - tool
          description: Rollenkennung, fest auf `tool` gesetzt
        content:
          type: string
          description: Inhalt des Werkzeugaufruf-Ergebnisses
        tool_call_id:
          type: string
          description: >-
            Werkzeugaufruf-ID


            Entspricht dem Feld `id`, das in `tool_calls` der
            Assistentennachricht zurückgegeben wird
    Tool:
      type: object
      required:
        - type
        - function
      properties:
        type:
          type: string
          enum:
            - function
          description: Werkzeugtyp, derzeit wird nur `function` unterstützt
        function:
          type: object
          required:
            - name
            - parameters
          properties:
            name:
              type: string
              description: >-
                Name der aufzurufenden Funktion


                **Hinweise**:

                - Muss aus den Zeichen a-z, A-Z, 0-9 bestehen oder Unterstriche
                und Bindestriche enthalten

                - Maximale Länge beträgt 64 Zeichen
            description:
              type: string
              description: >-
                Funktionsbeschreibung, hilft dem Modell zu verstehen, wann und
                wie diese Funktion aufgerufen wird
            parameters:
              type: object
              description: >-
                Eingabeparameter der Funktion, beschrieben als
                JSON-Schema-Objekt
    Choice:
      type: object
      properties:
        index:
          type: integer
          description: Index der Option
          example: 0
        message:
          $ref: '#/components/schemas/AssistantMessage'
        finish_reason:
          type: string
          description: |-
            Abschlussgrund

            - `stop`: Natürlicher Abschluss oder Stoppsequenz ausgelöst
            - `length`: Maximales Token-Limit erreicht
            - `content_filter`: Inhalt durch Sicherheitsrichtlinie gefiltert
            - `tool_calls`: Modell hat ein Werkzeug aufgerufen
          enum:
            - stop
            - length
            - content_filter
            - tool_calls
          example: stop
    Usage:
      type: object
      description: Token-Nutzungsstatistik
      properties:
        total_tokens:
          type: integer
          description: Gesamtanzahl der verbrauchten Tokens
          example: 1604
        total_characters:
          type: integer
          description: Gesamtanzahl der verbrauchten Zeichen
          example: 0
        prompt_tokens:
          type: integer
          description: Anzahl der Tokens in der Eingabe
          example: 1365
        completion_tokens:
          type: integer
          description: Anzahl der Tokens in der Ausgabe
          example: 239
        prompt_tokens_details:
          type: object
          description: Detaillierte Aufschlüsselung der Eingabe-Tokens
          properties:
            cached_tokens:
              type: integer
              description: Anzahl der Eingabe-Tokens, die den Cache getroffen haben
              example: 114
    ContentPart:
      type: object
      description: >-
        Multimodaler Content-Part. Deklarieren Sie den Typ über `type` und
        füllen Sie nur die zu diesem Typ passenden Felder aus
      properties:
        type:
          type: string
          enum:
            - text
            - image_url
            - video_url
          description: |-
            Inhaltstyp

            - `text`: Textblock
            - `image_url`: Bildeingabe
            - `video_url`: Videoeingabe
        text:
          type: string
          description: Textinhalt, wenn `type=text`
        image_url:
          type: object
          description: >-
            Bildeingabe (wenn `type=image_url`). Maximal 10 MB pro Bild,
            unterstützt JPEG / PNG / GIF / WEBP
          required:
            - url
          properties:
            url:
              type: string
              description: Bild-URL oder eine base64-Daten-URL, die mit `data:` beginnt
            detail:
              type: string
              description: >-
                Steuert die Auflösung der Bildanalyse


                - `low`: Niedrige Präzision, verbraucht weniger Tokens

                - `default`: Standardpräzision

                - `high`: Hohe Präzision, erkennt mehr Details, verbraucht aber
                mehr Tokens
              enum:
                - low
                - default
                - high
              default: default
            max_long_side_pixel:
              type: integer
              description: Maximale Pixelgrenze für die längste Seite des Bildes
              minimum: 1
        video_url:
          type: object
          description: >-
            Videoeingabe (wenn `type=video_url`). Maximal 50 MB für URL- /
            Base64-Video, unterstützt MP4 / AVI / MOV / MKV
          required:
            - url
          properties:
            url:
              type: string
              description: >-
                Video-URL, eine base64-Daten-URL, die mit `data:` beginnt, oder
                eine Dateireferenz im Format `mm_file://{file_id}`
            detail:
              type: string
              description: Steuert die Auflösung der Video-Frame-Extraktion
              enum:
                - low
                - default
                - high
              default: default
            fps:
              type: number
              description: >-
                Frame-Extraktionsrate des Videos, Standard 1, Bereich [0.2, 5]


                - Höhere Werte: Empfindlicher gegenüber visuellen Änderungen,
                höhere Token-Kosten und langsamer

                - Niedrigere Werte: Geringere Token-Kosten und schneller, aber
                weniger empfindlich gegenüber visuellen Änderungen
              minimum: 0.2
              maximum: 5
              default: 1
            max_long_side_pixel:
              type: integer
              description: Maximale Pixelgrenze für die längste Seite von Video-Frames
              minimum: 1
    AssistantMessage:
      type: object
      properties:
        role:
          type: string
          description: Rolle des Nachrichtenabsenders
          enum:
            - assistant
          example: assistant
        content:
          type:
            - string
            - 'null'
          description: >-
            Inhalt der KI-Antwortnachricht (kann `null` sein, wenn ein
            Werkzeugaufruf ausgelöst wird)
          example: >-
            Hallo! Ich bin MiniMax-M3 und kann dir bei Konversation, Schreiben,
            logischem Denken, Programmieren und vielen anderen Aufgaben helfen.
        reasoning_content:
          type: string
          description: >-
            Denkinhalt. Wird nur zurückgegeben, wenn in der Anfrage
            `reasoning_split=true` gesetzt ist; standardmäßig wird der
            Denkinhalt inline in `content` innerhalb von
            `<think>...</think>`-Tags eingebettet
          example: Lass mich dieses Problem analysieren...
        reasoning_details:
          type: array
          description: >-
            Strukturierter Denkinhalt. Wird nur zurückgegeben, wenn in der
            Anfrage `reasoning_split=true` gesetzt ist
          items:
            type: object
            properties:
              type:
                type: string
                description: Typ des Denkinhalts, z. B. `reasoning.text`
              id:
                type: string
                description: Kennung für das Denksegment
              format:
                type: string
                description: Formatkennung für den Denkinhalt, z. B. `MiniMax-response-v1`
              index:
                type: integer
                description: Fortlaufender Index des Denksegments
              text:
                type: string
                description: Denktext dieses Segments
        name:
          type: string
          description: Name des Absenders
        audio_content:
          type: string
          description: >-
            Audioinhalt (leere Zeichenkette bei reinen
            Textkonversationsszenarien)
        tool_calls:
          type: array
          description: >-
            Liste der Werkzeugaufrufe (wird zurückgegeben, wenn das Modell
            beschließt, ein Werkzeug aufzurufen)
          items:
            type: object
            properties:
              id:
                type: string
                description: Eindeutige Kennung für den Werkzeugaufruf
              type:
                type: string
                enum:
                  - function
              function:
                type: object
                properties:
                  name:
                    type: string
                    description: Name der aufgerufenen Funktion
                  arguments:
                    type: string
                    description: Funktionsargumente (JSON-Zeichenkette)
              index:
                type: integer
                description: Index des Werkzeugaufrufs
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        ##Alle APIs erfordern eine Bearer-Token-Authentifizierung##


        **API-Key erhalten:**


        Besuchen Sie die
        [API-Key-Verwaltungsseite](https://evolink.ai/dashboard/keys), um Ihren
        API-Key zu erhalten


        **Zum Anfrage-Header hinzufügen:**

        ```

        Authorization: Bearer YOUR_API_KEY

        ```

````