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

# DeepSeek V4 - OpenAI-kompatible API

> - Verwenden Sie das OpenAI Chat Completions Protokoll, um die DeepSeek V4 Modelle aufzurufen
- Unterstützt `deepseek-v4-flash` (schnell und universell) und `deepseek-v4-pro` (tiefes Reasoning)
- **Textkonversation**: Einzel- oder Mehrrunden-Kontext-Dialog mit Unterstützung für 1M Ultra-Langkontext
- **System-Prompts**: KI-Rolle und -Verhalten anpassen
- **Thinking-Modus**: Tiefes Reasoning über `thinking.type` steuern; bei `deepseek-v4-pro` wird der Denkinhalt über `reasoning_content` zurückgegeben
- **Streaming-Ausgabe**: SSE-Streaming wird unterstützt
- **Tool-Aufrufe**: Unterstützt Function Calling (bis zu 128 Tools)
- **JSON-Modus**: Über `response_format` aktivierbar
- **Kontext-Cache**: Anfragen mit identischem Präfix treffen automatisch den Cache und reduzieren die Input-Kosten erheblich

<Note>
  **BaseURL**: Die Standard-BaseURL ist `https://direct.evolink.ai` und bietet bessere Unterstützung für Textmodelle sowie persistente Verbindungen. `https://api.evolink.ai` ist der primäre Endpunkt für multimodale Dienste und dient bei Textmodellen als Ausweichadresse.
</Note>


## OpenAPI

````yaml de/api-manual/language-series/deepseek-v4/deepseek-v4-chat.json POST /v1/chat/completions
openapi: 3.1.0
info:
  title: DeepSeek V4 Vollständige Parameter-Dokumentation (OpenAI-kompatibel)
  description: >-
    Vollständige API-Referenz für die Chat-Schnittstelle der DeepSeek V4 Serie
    (`deepseek-v4-flash` / `deepseek-v4-pro`).


    **Modellfähigkeiten**:

    - Kontextlänge: **1.000.000 Tokens** (1M)

    - Maximale Ausgabe: **384.000 Tokens** (384K)

    - Thinking-Modus: Über das Feld `thinking` umschaltbar; `deepseek-v4-pro`
    ist besonders stark bei komplexem Reasoning

    - Kontext-Festplattencache: Automatische Treffer; Treffer und Fehltreffer
    werden separat abgerechnet


    **Abrechnungsstufen (UC/1K Tokens, EvoLink-interne Einheit)**:

    | Modell | Input Cache-Treffer | Input Cache-Fehltreffer | Output |

    | --- | --- | --- | --- |

    | deepseek-v4-flash | 20 | 100 | 200 |

    | deepseek-v4-pro | 100 | 1200 | 2400 |
  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-Generierung
    description: Endpunkte für KI-Chat-Generierung
paths:
  /v1/chat/completions:
    post:
      tags:
        - Chat-Generierung
      summary: DeepSeek V4 Chat-Schnittstelle (OpenAI-kompatibel)
      description: >-
        - Verwenden Sie das OpenAI Chat Completions Protokoll, um die DeepSeek
        V4 Modelle aufzurufen

        - Unterstützt `deepseek-v4-flash` (schnell und universell) und
        `deepseek-v4-pro` (tiefes Reasoning)

        - **Textkonversation**: Einzel- oder Mehrrunden-Kontext-Dialog mit
        Unterstützung für 1M Ultra-Langkontext

        - **System-Prompts**: KI-Rolle und -Verhalten anpassen

        - **Thinking-Modus**: Tiefes Reasoning über `thinking.type` steuern; bei
        `deepseek-v4-pro` wird der Denkinhalt über `reasoning_content`
        zurückgegeben

        - **Streaming-Ausgabe**: SSE-Streaming wird unterstützt

        - **Tool-Aufrufe**: Unterstützt Function Calling (bis zu 128 Tools)

        - **JSON-Modus**: Über `response_format` aktivierbar

        - **Kontext-Cache**: Anfragen mit identischem Präfix treffen automatisch
        den Cache und reduzieren die Input-Kosten erheblich
      operationId: createChatCompletionDeepSeekV4
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ChatCompletionRequest'
            examples:
              simple_text:
                summary: Einrundige Textkonversation (Flash)
                value:
                  model: deepseek-v4-flash
                  messages:
                    - role: user
                      content: Bitte stellen Sie sich vor
              multi_turn:
                summary: Mehrrunden-Dialog (Kontextverständnis)
                value:
                  model: deepseek-v4-flash
                  messages:
                    - role: user
                      content: Was ist Python?
                    - role: assistant
                      content: Python ist eine Hochsprache...
                    - role: user
                      content: Welche Vorteile hat es?
              system_prompt:
                summary: Verwendung von System-Prompts
                value:
                  model: deepseek-v4-flash
                  messages:
                    - role: system
                      content: >-
                        Sie sind ein professioneller
                        Python-Programmier-Assistent. Beantworten Sie Fragen
                        prägnant.
                    - role: user
                      content: Wie lese ich eine Datei?
              thinking_mode:
                summary: Pro-Modell verwenden + Thinking-Modus explizit aktivieren
                value:
                  model: deepseek-v4-pro
                  thinking:
                    type: enabled
                    reasoning_effort: high
                  messages:
                    - role: user
                      content: Beweisen Sie, dass √2 irrational ist
              disable_thinking:
                summary: Thinking-Modus deaktivieren (nur direkte Antwort)
                value:
                  model: deepseek-v4-pro
                  thinking:
                    type: disabled
                  messages:
                    - role: user
                      content: Was ist die Hauptstadt Frankreichs?
              json_mode:
                summary: JSON-Modus strukturierte Ausgabe
                value:
                  model: deepseek-v4-flash
                  response_format:
                    type: json_object
                  messages:
                    - role: system
                      content: Sie müssen striktes JSON ausgeben.
                    - role: user
                      content: >-
                        Geben Sie mir ein Beispiel-JSON mit den Feldern name und
                        age
              tool_calling:
                summary: Function Calling Tool-Aufrufe
                value:
                  model: deepseek-v4-flash
                  messages:
                    - role: user
                      content: Fragen Sie das heutige Wetter in Peking ab
                  tools:
                    - type: function
                      function:
                        name: get_weather
                        description: Wetterinformationen für eine bestimmte Stadt abfragen
                        parameters:
                          type: object
                          properties:
                            city:
                              type: string
                              description: Name der Stadt
                          required:
                            - city
                  tool_choice: auto
              streaming:
                summary: Streaming-Ausgabe
                value:
                  model: deepseek-v4-flash
                  stream: true
                  stream_options:
                    include_usage: true
                  messages:
                    - role: user
                      content: Schreiben Sie ein kurzes Gedicht über den Frühling
      responses:
        '200':
          description: Chat-Generierung erfolgreich
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ChatCompletionResponse'
              examples:
                thinking_disabled:
                  summary: thinking deaktiviert (reine Textantwort)
                  value:
                    id: 837f529d-00f9-4731-b2e1-4a54fc31790a
                    object: chat.completion
                    created: 1777026806
                    model: deepseek-v4-flash
                    choices:
                      - index: 0
                        message:
                          role: assistant
                          content: >-
                            Hallo! Ich bin der DeepSeek-Assistent, jederzeit
                            bereit, Ihre Fragen zu beantworten und zu helfen.
                        logprobs: null
                        finish_reason: stop
                    usage:
                      prompt_tokens: 7
                      completion_tokens: 31
                      total_tokens: 38
                      prompt_tokens_details:
                        cached_tokens: 0
                      prompt_cache_hit_tokens: 0
                      prompt_cache_miss_tokens: 7
                    system_fingerprint: fp_evolink_v4_20260402
                thinking_enabled:
                  summary: thinking aktiviert (mit reasoning_content)
                  value:
                    id: 658083bb-1137-49d2-8c4d-900e508cbd53
                    object: chat.completion
                    created: 1777026807
                    model: deepseek-v4-flash
                    choices:
                      - index: 0
                        message:
                          role: assistant
                          content: Die Hauptstadt Frankreichs ist **Paris**.
                          reasoning_content: >-
                            Der Benutzer fragt: "Was ist die Hauptstadt
                            Frankreichs?" — eine allgemeinwissensbezogene Frage.
                            Einfach direkt mit "Paris" antworten.
                        logprobs: null
                        finish_reason: stop
                    usage:
                      prompt_tokens: 7
                      completion_tokens: 53
                      total_tokens: 60
                      prompt_tokens_details:
                        cached_tokens: 0
                      completion_tokens_details:
                        reasoning_tokens: 45
                      prompt_cache_hit_tokens: 0
                      prompt_cache_miss_tokens: 7
                    system_fingerprint: fp_evolink_v4_20260402
                cache_hit:
                  summary: Context-Cache-Treffer (große Menge cache_hit_tokens)
                  value:
                    id: 3e4a1b70-8c59-4b22-a011-9f2c7d5a3e88
                    object: chat.completion
                    created: 1777026900
                    model: deepseek-v4-flash
                    choices:
                      - index: 0
                        message:
                          role: assistant
                          content: Hallo!
                        logprobs: null
                        finish_reason: stop
                    usage:
                      prompt_tokens: 694
                      completion_tokens: 10
                      total_tokens: 704
                      prompt_tokens_details:
                        cached_tokens: 640
                      prompt_cache_hit_tokens: 640
                      prompt_cache_miss_tokens: 54
                    system_fingerprint: fp_evolink_v4_20260402
        '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: Unzureichendes Kontingent, Aufladung erforderlich
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: 402
                  message: Insufficient quota
                  type: insufficient_quota_error
        '403':
          description: Keine Berechtigung für dieses Modell
          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: Anfrage-Nutzlast 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: Ratenlimit ü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: Gateway-Fehler
          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


            - `deepseek-v4-flash`: Schnelles Universalmodell, 1M Kontext

            - `deepseek-v4-pro`: Modell für tiefes Reasoning, stark in
            Mathematik, Programmierung und komplexer Logik


            **Hinweis**: Beide Modelle **haben `thinking` standardmäßig
            aktiviert**, die Antwort enthält `reasoning_content`. Über
            `thinking.type="disabled"` kann es deaktiviert werden, um die
            Output-Token-Kosten zu senken. Die Parameter beider Modelle sind
            identisch.
          enum:
            - deepseek-v4-flash
            - deepseek-v4-pro
          default: deepseek-v4-flash
          example: deepseek-v4-flash
        messages:
          type: array
          description: >-
            Liste der Konversationsnachrichten, unterstützt Mehrrunden-Dialog


            Nachrichten verschiedener Rollen haben unterschiedliche
            Feldstrukturen. Bitte wählen Sie die entsprechende Rolle zur
            Ansicht.
          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: >-
            Thinking-Modus Steuerung (neu in V4)


            **Hinweis**:

            - Steuert die Chain-of-Thought-Funktion

            - **Bei beiden Modellen standardmäßig aktiviert** (`type=enabled`)

            - Bei Aktivierung wird der Reasoning-Prozess über
            `choices[].message.reasoning_content` zurückgegeben und als
            Output-Token abgerechnet


            ⚠️ **Hinweis für Mehrrunden-Dialog / Tool-Aufrufe**: Wenn die
            aktuelle Antwort `reasoning_content` enthält, **muss in der nächsten
            Anfrage die entsprechende assistant-Nachricht in der
            `messages`-Historie dieses Feld unverändert zurückgeben**, sonst
            antwortet die API mit 400 `The reasoning_content in the thinking
            mode must be passed back to the API`. Wenn Sie dies nicht handhaben
            möchten, können Sie für die gesamte Sitzung
            `thinking.type="disabled"` explizit setzen.
          properties:
            type:
              type: string
              description: >-
                Schalter für den Thinking-Modus


                - `enabled`: Tiefes Denken aktivieren (Standard)

                - `disabled`: Tiefes Denken deaktivieren, Modell antwortet
                direkt
              enum:
                - enabled
                - disabled
              default: enabled
            reasoning_effort:
              type: string
              description: >-
                Grad des Reasoning-Aufwands


                - `low`: Geringer Aufwand, schnellere Antwort, weniger
                reasoning_tokens

                - `medium`: Mittlerer Aufwand (Standard)

                - `high`: Hoher Aufwand, gründlicherer Denkprozess, mehr
                reasoning_tokens-Verbrauch
              enum:
                - low
                - medium
                - high
              default: medium
        temperature:
          type: number
          description: >-
            Sampling-Temperatur, steuert die Zufälligkeit der Ausgabe


            **Hinweis**:

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

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

            - Standardwert: 1
          minimum: 0
          maximum: 2
          default: 1
          example: 1
        top_p:
          type: number
          description: >-
            Nucleus-Sampling-Parameter


            **Hinweis**:

            - Steuert das Sampling von Token mit kumulativer Wahrscheinlichkeit

            - Zum Beispiel bedeutet 0,9, dass aus Token mit den oberen 90%
            kumulativer Wahrscheinlichkeit gesampelt wird

            - Standardwert: 1.0 (berücksichtigt alle Token)


            **Empfehlung**: Passen Sie nicht gleichzeitig temperature und top_p
            an
          minimum: 0
          maximum: 1
          default: 1
          example: 1
        max_tokens:
          type: integer
          description: >-
            Begrenzt die maximale Anzahl der zu generierenden Tokens


            **Hinweis**:

            - V4-Serie kann maximal **384.000 Tokens** erreichen

            - Bei aktiviertem Thinking werden reasoning_tokens ebenfalls auf
            max_tokens angerechnet

            - Ohne Angabe entscheidet das Modell selbst über die
            Generierungslänge
          minimum: 1
          maximum: 384000
          example: 4096
        frequency_penalty:
          type: number
          description: >-
            Häufigkeitsstrafe, zur Reduzierung wiederholter Inhalte


            **Hinweis**:

            - Positive Werte bestrafen Tokens basierend auf ihrer Häufigkeit im
            bereits generierten Text

            - Je größer der Wert, desto weniger wahrscheinlich werden bereits
            vorhandene Inhalte wiederholt

            - Standardwert: 0 (keine Strafe)
          minimum: -2
          maximum: 2
          default: 0
          example: 0
        presence_penalty:
          type: number
          description: >-
            Anwesenheitsstrafe, zur Förderung neuer Themen


            **Hinweis**:

            - Positive Werte bestrafen Tokens basierend darauf, ob sie bereits
            im Text vorgekommen sind

            - Je größer der Wert, desto eher werden neue Themen besprochen

            - Standardwert: 0 (keine Strafe)
          minimum: -2
          maximum: 2
          default: 0
          example: 0
        response_format:
          type: object
          description: >-
            Gibt das Antwortformat an


            **Hinweis**:

            - Setzen Sie auf `{"type": "json_object"}`, um den JSON-Modus zu
            aktivieren

            - Im JSON-Modus gibt das Modell gültige JSON-Inhalte aus

            - Es wird empfohlen, die JSON-Ausgabe in der system- oder
            user-Nachricht explizit zu verlangen, um optimale Ergebnisse zu
            erzielen
          properties:
            type:
              type: string
              enum:
                - text
                - json_object
              description: Antwortformat-Typ
              default: text
        stop:
          description: >-
            Stoppsequenzen, das Modell stoppt die Generierung, wenn es diese
            Zeichenketten trifft


            **Hinweis**:

            - Kann eine einzelne Zeichenkette oder ein Array von Zeichenketten
            sein

            - Maximal 16 Stoppsequenzen werden unterstützt
          oneOf:
            - type: string
            - type: array
              items:
                type: string
              maxItems: 16
        stream:
          type: boolean
          description: >-
            Ob die Antwort als Stream zurückgegeben werden soll


            - `true`: Stream-Antwort, Inhalt wird über SSE (Server-Sent Events)
            blockweise in Echtzeit zurückgegeben

            - `false`: Auf vollständige Antwort warten und alles auf einmal
            zurückgeben (Standard)
          default: false
          example: false
        stream_options:
          type: object
          description: |-
            Optionen für Stream-Antworten

            Nur wirksam, wenn `stream=true`
          properties:
            include_usage:
              type: boolean
              description: >-
                Gibt am Ende des Streams Usage-Statistiken zurück
                (einschließlich Cache-Aufschlüsselung)
        tools:
          type: array
          description: |-
            Liste der Tool-Definitionen für Function Calling

            **Hinweis**:
            - Maximal 128 Tool-Definitionen werden unterstützt
            - Jedes Tool muss Name, Beschreibung und Parameter-Schema definieren
          items:
            $ref: '#/components/schemas/Tool'
          maxItems: 128
        tool_choice:
          description: >-
            Steuert das Verhalten der Tool-Aufrufe


            **Mögliche Werte**:

            - `none`: Kein Tool aufrufen

            - `auto`: Modell entscheidet automatisch, ob ein Tool aufgerufen
            wird (Standard, wenn tools bereitgestellt werden)

            - `required`: Modell muss ein oder mehrere Tools aufrufen

            - Objektform `{"type":"function","function":{"name":"xxx"}}`: Ein
            bestimmtes Tool aufrufen


            **Standardwert**: `none`, wenn keine tools bereitgestellt werden;
            `auto`, wenn tools bereitgestellt werden
          oneOf:
            - type: string
              enum:
                - none
                - auto
                - required
            - type: object
              description: Spezifisches Tool zum Aufruf angeben
              properties:
                type:
                  type: string
                  enum:
                    - function
                function:
                  type: object
                  properties:
                    name:
                      type: string
                      description: Name der aufzurufenden Funktion
                  required:
                    - name
        logprobs:
          type: boolean
          description: >-
            Ob die Log-Wahrscheinlichkeiten der Tokens zurückgegeben werden
            sollen


            **Hinweis**:

            - Bei `true` enthält die Antwort
            Log-Wahrscheinlichkeitsinformationen für jedes Token
          default: false
        top_logprobs:
          type: integer
          description: |-
            Gibt die Log-Wahrscheinlichkeiten der Top-N Tokens zurück

            **Hinweis**:
            - Erfordert `logprobs` auf `true` gesetzt
            - Wertebereich: `[0, 20]`
          minimum: 0
          maximum: 20
        logit_bias:
          type: object
          description: >-
            Token-Bias-Mapping


            **Hinweis**:

            - Schlüssel ist die Token-ID im Tokenizer, Wert ist ein Bias
            zwischen -100 und 100

            - -100 bedeutet, dass das Token vollständig verboten ist, 100
            bedeutet erzwungene Generierung

            - Typische Werte zwischen -1 und 1 haben bereits eine beobachtbare
            Wirkung
          additionalProperties:
            type: number
            minimum: -100
            maximum: 100
        'n':
          type: integer
          description: >-
            Anzahl der zu generierenden Chat-Vervollständigungen pro
            Eingabenachricht


            **Hinweis**:

            - Standard 1; bei N werden N Kandidaten zurückgegeben (berechnet
            nach N × output_tokens)
          minimum: 1
          maximum: 8
          default: 1
          example: 1
        seed:
          type: integer
          description: >-
            Zufalls-Seed (Beta)


            **Hinweis**:

            - Bei Angabe versucht das Modell deterministisches Sampling

            - Gleicher Seed + gleiche andere Parameter → gleiche Ausgabe (nicht
            100% garantiert)
        user:
          type: string
          description: >-
            Eindeutiger Bezeichner des Endbenutzers


            **Hinweis**:

            - Hilft der Plattform bei der Überwachung und Erkennung von
            Missbrauch

            - Empfohlen ist die Verwendung einer gehashten Benutzer-ID
    ChatCompletionResponse:
      type: object
      properties:
        id:
          type: string
          description: Eindeutiger Bezeichner der Chat-Vervollständigung
          example: 53c548dc-ec02-4a2f-bbb6-eca4184630b8
        model:
          type: string
          description: Name des tatsächlich verwendeten Modells
          example: deepseek-v4-flash
        object:
          type: string
          enum:
            - chat.completion
          description: Antworttyp
          example: chat.completion
        created:
          type: integer
          description: Erstellungszeitstempel (Unix-Sekunden)
          example: 1777021417
        choices:
          type: array
          description: Liste der Auswahlmöglichkeiten der Chat-Generierung
          items:
            $ref: '#/components/schemas/Choice'
        usage:
          $ref: '#/components/schemas/Usage'
        system_fingerprint:
          type: string
          description: System-Fingerprint-Kennung
          example: fp_evolink_v4_20260402
    ErrorResponse:
      type: object
      properties:
        error:
          type: object
          properties:
            code:
              type: integer
              description: HTTP-Status-Fehlercode
            message:
              type: string
              description: Fehlerbeschreibung
            type:
              type: string
              description: Fehlertyp
            param:
              type: string
              description: Zugehöriger Parametername
    SystemMessage:
      title: System Message
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - system
          description: Rollenkennung, fest `system`
        content:
          type: string
          description: >-
            Inhalt des System-Prompts, zur Festlegung von Rolle und Verhalten
            der KI
        name:
          type: string
          description: >-
            Name des Teilnehmers, zur Unterscheidung verschiedener
            System-Prompt-Quellen
    UserMessage:
      title: User Message
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - user
          description: Rollenkennung, fest `user`
        content:
          type: string
          description: Inhalt der Benutzernachricht (reine Textzeichenkette)
        name:
          type: string
          description: Name des Teilnehmers, zur Unterscheidung verschiedener Benutzer
    AssistantRequestMessage:
      title: Assistant Message
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - assistant
          description: Rollenkennung, fest `assistant`
        content:
          type:
            - string
            - 'null'
          description: >-
            Inhalt der Assistent-Nachricht


            **Hinweis**:

            - Wird in Mehrrunden-Dialogen zur Übergabe historischer
            Assistent-Antworten verwendet

            - Kann `null` sein, wenn `tool_calls` vorhanden ist
        name:
          type: string
          description: Name des Teilnehmers
        prefix:
          type: boolean
          description: >-
            Ob der Präfix-Fortsetzungsmodus aktiviert werden soll (Beta)


            **Hinweis**:

            - Nur in der letzten Nachricht setzen

            - Bei `true` setzt das Modell die Generierung mit dem `content`
            dieser Nachricht als Präfix fort
          default: false
        reasoning_content:
          type:
            - string
            - 'null'
          description: >-
            Inhalt der Gedankenkette (Beta)


            **Hinweis**:

            - Wird sowohl von `deepseek-v4-flash` als auch `deepseek-v4-pro` bei
            aktiviertem thinking (Standard) erzeugt

            - **Im Mehrrunden-Szenario muss er unverändert zurückgegeben
            werden**: Übergeben Sie den `choices[0].message.reasoning_content`
            aus der vorherigen Antwort direkt als `reasoning_content`-Feld der
            historischen assistant-Nachricht; ein Fehlen wird von der API
            abgelehnt (400)

            - Bei der Übergabe als historischer Kontext ist keine Kombination
            mit `prefix` erforderlich; nur bei explizit aktivierter
            Präfix-Fortsetzung `prefix=true`
        tool_calls:
          type: array
          description: >-
            Liste der Tool-Aufrufe


            Wird verwendet, um historische Tool-Aufrufinformationen in
            Mehrrunden-Dialogen zu übergeben
          items:
            type: object
            properties:
              id:
                type: string
                description: Eindeutiger Bezeichner des Tool-Aufrufs
              type:
                type: string
                enum:
                  - function
              function:
                type: object
                properties:
                  name:
                    type: string
                    description: Name der aufgerufenen Funktion
                  arguments:
                    type: string
                    description: Funktionsparameter (JSON-Zeichenkette)
    ToolMessage:
      title: Tool Message
      type: object
      required:
        - role
        - content
        - tool_call_id
      properties:
        role:
          type: string
          enum:
            - tool
          description: Rollenkennung, fest `tool`
        content:
          type: string
          description: Inhalt des vom Tool-Aufruf zurückgegebenen Ergebnisses
        tool_call_id:
          type: string
          description: >-
            Tool-Aufruf-ID


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


                **Hinweis**:

                - 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: >-
                Beschreibung der Funktion, damit das Modell versteht, wann und
                wie diese Funktion aufgerufen werden soll
            parameters:
              type: object
              description: >-
                Eingabeparameter der Funktion, beschrieben als
                JSON-Schema-Objekt


                **Hinweis**:

                - Das Auslassen von `parameters` definiert eine Funktion mit
                einer leeren Parameterliste
            strict:
              type: boolean
              description: >-
                Ob der Strict-Modus aktiviert werden soll (Beta)


                **Hinweis**:

                - Bei `true` verwendet die API den Strict-Modus für
                Funktionsaufrufe

                - Stellt sicher, dass die Ausgabe stets der
                JSON-Schema-Definition der Funktion entspricht
              default: false
    Choice:
      type: object
      properties:
        index:
          type: integer
          description: Index der Auswahl
          example: 0
        message:
          $ref: '#/components/schemas/AssistantMessage'
        logprobs:
          type:
            - object
            - 'null'
          description: >-
            Log-Wahrscheinlichkeitsinformationen (nur zurückgegeben, wenn
            `logprobs=true` angefordert wurde)
        finish_reason:
          type: string
          description: |-
            Grund für den Abschluss

            - `stop`: Natürliches Ende oder Stoppsequenz ausgelöst
            - `length`: Maximales Token-Limit erreicht
            - `content_filter`: Inhalt wurde vom Sicherheitsfilter blockiert
            - `tool_calls`: Modell hat ein Tool aufgerufen
            - `insufficient_system_resource`: Unzureichende Backend-Ressourcen
          enum:
            - stop
            - length
            - content_filter
            - tool_calls
            - insufficient_system_resource
          example: stop
    Usage:
      type: object
      description: >-
        Token-Nutzungsstatistiken (einschließlich Cache- und
        Reasoning-Aufschlüsselung)
      properties:
        prompt_tokens:
          type: integer
          description: >-
            Gesamtanzahl der Tokens im Input (einschließlich Cache-Treffer und
            -Fehltreffer)
          example: 694
        completion_tokens:
          type: integer
          description: Anzahl der Tokens im Output (einschließlich reasoning-Teil)
          example: 20
        total_tokens:
          type: integer
          description: Gesamtanzahl der Tokens = prompt_tokens + completion_tokens
          example: 714
        prompt_cache_hit_tokens:
          type: integer
          description: >-
            Anzahl der im Input den Kontext-Cache treffenden Tokens


            **Hinweis**: Cache-Treffer-Tokens werden zum **Cache-Treffer-Preis**
            abgerechnet (Flash 20 UC/1K, Pro 100 UC/1K)
          example: 640
        prompt_cache_miss_tokens:
          type: integer
          description: >-
            Anzahl der im Input den Cache verfehlenden Tokens


            **Hinweis**: Wird zum **Standard-Input-Preis** abgerechnet (Flash
            100 UC/1K, Pro 1200 UC/1K)
          example: 54
        prompt_tokens_details:
          type: object
          description: Detaillierte Aufschlüsselung der Input-Tokens (OpenAI-Stil)
          properties:
            cached_tokens:
              type: integer
              description: >-
                Anzahl der Cache-Treffer-Tokens (entspricht
                `prompt_cache_hit_tokens`, wird vom Framework automatisch
                zugeordnet)
              example: 640
        completion_tokens_details:
          type: object
          description: Detaillierte Aufschlüsselung der Output-Tokens
          properties:
            reasoning_tokens:
              type: integer
              description: >-
                Anzahl der im Thinking-Modus erzeugten Reasoning-Tokens (wird
                zum Output gezählt und zum Output-Preis abgerechnet)
              example: 10
    AssistantMessage:
      type: object
      properties:
        role:
          type: string
          description: Rolle des Nachrichtenabsenders
          enum:
            - assistant
          example: assistant
        content:
          type: string
          description: Antwortinhalt der KI
          example: >-
            Hallo! Ich bin DeepSeek V4. Ich bin gut in allgemeinen Gesprächen,
            Codegenerierung, mathematischen Überlegungen und vielen weiteren
            Aufgaben.
        reasoning_content:
          type: string
          description: >-
            Inhalt der Gedankenkette (wird nur bei aktiviertem thinking
            zurückgegeben)


            **Hinweis**:

            - `deepseek-v4-pro` ist standardmäßig aktiviert und gibt den
            vollständigen Reasoning-Prozess zurück

            - `deepseek-v4-flash` erfordert die explizite Einstellung
            `thinking.type="enabled"`, um den Inhalt zurückzugeben

            - Wird als Output-Token abgerechnet und auf
            `completion_tokens_details.reasoning_tokens` angerechnet
          example: Lassen Sie mich diese Frage analysieren...
        tool_calls:
          type: array
          description: >-
            Liste der Tool-Aufrufe (wird zurückgegeben, wenn das Modell
            entscheidet, ein Tool aufzurufen)
          items:
            type: object
            properties:
              id:
                type: string
                description: Eindeutiger Bezeichner des Tool-Aufrufs
              type:
                type: string
                enum:
                  - function
              function:
                type: object
                properties:
                  name:
                    type: string
                    description: Name der aufgerufenen Funktion
                  arguments:
                    type: string
                    description: Funktionsparameter (JSON-Zeichenkette)
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        ##Alle APIs erfordern Bearer-Token-Authentifizierung##


        **API-Schlüssel erhalten**:


        Besuchen Sie die
        [API-Schlüsselverwaltungsseite](https://evolink.ai/dashboard/keys), um
        Ihren API-Schlüssel zu erhalten


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

        ```

        Authorization: Bearer YOUR_API_KEY

        ```

````