koboldcpp_api.json

{
	"components": {
		"schemas": {
			"BasicError": {
				"properties": {
					"msg": {
						"type": "string"
					},
					"type": {
						"type": "string"
					}
				},
				"required": [
					"msg",
					"type"
				],
				"type": "object"
			},
			"BasicResult": {
				"properties": {
					"result": {
						"type": "string"
					}
				},
				"required": [
					"result"
				],
				"type": "object"
			},
			"GenerationInput": {
				"properties": {
					"max_context_length": {
						"description": "Maximum number of tokens to send to the model.",
						"minimum": 1,
						"type": "integer"
					},
					"max_length": {
						"description": "Number of tokens to generate.",
						"minimum": 1,
						"type": "integer"
					},
					"prompt": {
						"description": "This is the submission.",
						"type": "string"
					},
					"rep_pen": {
						"description": "Base repetition penalty value.",
						"minimum": 1,
						"type": "number"
					},
					"rep_pen_range": {
						"description": "Repetition penalty range.",
						"minimum": 0,
						"type": "integer"
					},
					"sampler_order": {
						"description": "Sampler order to be used. If N is the length of this array, then N must be greater than or equal to 6 and the array must be a permutation of the first N non-negative integers.",
						"items": {
							"type": "integer"
						},
						"minItems": 6,
						"type": "array"
					},
					"sampler_seed": {
						"description": "RNG seed to use for sampling. If not specified, the global RNG will be used.",
						"maximum": 999999,
						"minimum": 1,
						"type": "integer"
					},
					"stop_sequence": {
						"description": "An array of string sequences where the API will stop generating further tokens. The returned text WILL contain the stop sequence if trim_stop is false.",
						"items": {
							"type": "string"
						},
						"type": "array"
					},
					"temperature": {
						"description": "Temperature value.",
						"minimum": 0,
						"type": "number"
					},
					"tfs": {
						"description": "Tail free sampling value.",
						"maximum": 1,
						"minimum": 0,
						"type": "number"
					},
					"top_a": {
						"description": "Top-a sampling value.",
						"minimum": 0,
						"type": "number"
					},
					"top_k": {
						"description": "Top-k sampling value.",
						"minimum": 0,
						"type": "integer"
					},
					"top_p": {
						"description": "Top-p sampling value.",
						"maximum": 1,
						"minimum": 0,
						"type": "number"
					},
					"min_p": {
						"description": "Min-p sampling value.",
						"maximum": 1,
						"minimum": 0,
						"type": "number"
					},
					"typical": {
						"description": "Typical sampling value.",
						"maximum": 1,
						"minimum": 0,
						"type": "number"
					},
					"use_default_badwordsids": {
						"default": false,
						"description": "If true, prevents the EOS token from being generated (Ban EOS).",
						"type": "boolean"
					},
					"dynatemp_range": {
						"default": 0,
						"description": "If not equal to 0, uses dynamic temperature. Dynamic temperature range will be between Temp+Range and Temp-Range. If equal to 0 , uses static temperature.",
						"minimum": -5,
						"maximum": 5,
						"type": "number"
					},
					"smoothing_factor": {
						"default": 0,
						"description": "Modifies temperature behavior. If greater than 0 uses smoothing factor.",
						"minimum": 0,
						"type": "number"
					},
					"dynatemp_exponent": {
						"default": 1,
						"description": "Exponent used in dynatemp.",
						"type": "number"
					},
					"mirostat": {
						"description": "KoboldCpp ONLY. Sets the mirostat mode, 0=disabled, 1=mirostat_v1, 2=mirostat_v2",
						"minimum": 0,
						"maximum": 2,
						"type": "number"
					},
					"mirostat_tau": {
						"description": "KoboldCpp ONLY. Mirostat tau value.",
						"minimum": 0,
						"type": "number"
					},
					"mirostat_eta": {
						"description": "KoboldCpp ONLY. Mirostat eta value.",
						"minimum": 0,
						"type": "number"
					},
					"genkey": {
						"description": "KoboldCpp ONLY. A unique genkey set by the user. When checking a polled-streaming request, use this key to be able to fetch pending text even if multiuser is enabled.",
						"type": "string"
					},
					"grammar": {
						"description": "KoboldCpp ONLY. A string containing the GBNF grammar to use.",
						"type": "string"
					},
					"grammar_retain_state": {
						"default": false,
						"description": "KoboldCpp ONLY. If true, retains the previous generation's grammar state, otherwise it is reset on new generation.",
						"type": "boolean"
					},
					"memory": {
						"description": "KoboldCpp ONLY. If set, forcefully appends this string to the beginning of any submitted prompt text. If resulting context exceeds the limit, forcefully overwrites text from the beginning of the main prompt until it can fit. Useful to guarantee full memory insertion even when you cannot determine exact token count.",
						"type": "string"
					},
					"images": {
						"description": "KoboldCpp ONLY. If set, takes an array of base64 encoded strings, each one representing an image to be processed.",
						"type": "array",
						"items": {
							"type": "string"
						}
					},
					"trim_stop": {
						"default": true,
						"description": "KoboldCpp ONLY. If true, also removes detected stop_sequences from the output and truncates all text after them. If false, output will also include stop sequence and potentially a few additional characters.",
						"type": "boolean"
					},
					"render_special": {
						"default": false,
						"description": "KoboldCpp ONLY. If true, prints special tokens as text for GGUF models",
						"type": "boolean"
					},
					"bypass_eos": {
						"default": false,
						"description": "KoboldCpp ONLY. If true, allows EOS token to be generated, but does not stop generation. Not recommended unless you know what you are doing.",
						"type": "boolean"
					},
					"banned_tokens": {
						"description": "An array of string sequences, each entry represents a word or phrase prevented from being generated, either modifying model vocab or by backtracking and regenerating when they appear.",
						"items": {
							"type": "string"
						},
						"type": "array"
					},
					"logit_bias": {
						"default": {},
						"description": "KoboldCpp ONLY. An dictionary of key-value pairs, which indicate the token IDs (int) and logit bias (float) to apply for that token.",
						"type": "object",
						"example": {
							"2": -20,
							"145": -1.4,
							"3105": 3.2
						}
					},
					"dry_multiplier": {
						"description": "KoboldCpp ONLY. DRY multiplier value, 0 to disable.",
						"minimum": 0,
						"type": "number"
					},
					"dry_base": {
						"description": "KoboldCpp ONLY. DRY base value.",
						"minimum": 0,
						"type": "number"
					},
					"dry_allowed_length": {
						"description": "KoboldCpp ONLY. DRY allowed length value.",
						"minimum": 0,
						"type": "number"
					},
					"dry_penalty_last_n": {
						"description": "KoboldCpp ONLY. DRY last n tokens penalized value.",
						"minimum": 0,
						"type": "number"
					},
					"dry_sequence_breakers": {
						"description": "An array of string sequence breakers for DRY.",
						"items": {
							"type": "string"
						},
						"type": "array"
					},
					"xtc_threshold": {
						"description": "KoboldCpp ONLY. XTC threshold.",
						"minimum": 0,
						"type": "number"
					},
					"xtc_probability": {
						"description": "KoboldCpp ONLY. XTC probability. Set to above 0 to enable XTC.",
						"minimum": 0,
						"type": "number"
					},
					"nsigma": {
						"description": "KoboldCpp ONLY. Top N-Sigma value. Set to above 0 to enable nsigma.",
						"minimum": 0,
						"type": "number"
					},
					"logprobs": {
						"default": false,
						"description": "If true, return up to 10 top logprobs for generated tokens. Incurs performance overhead.",
						"type": "boolean"
					},
					"replace_instruct_placeholders": {
						"default": false,
						"description": "If true, replaces instruct placeholders {{[INPUT]}} and {{[OUTPUT]}} with backend selected instruct tags.",
						"type": "boolean"
					}
				},
				"required": [
					"prompt"
				],
				"type": "object"
			},
			"GenerationOutput": {
				"properties": {
					"results": {
						"description": "Array of generated outputs.",
						"items": {
							"$ref": "#/components/schemas/GenerationResult"
						},
						"type": "array"
					}
				},
				"required": [
					"results"
				],
				"type": "object"
			},
			"GenerationResult": {
				"properties": {
					"text": {
						"description": "Generated output as plain text.",
						"type": "string"
					}
				},
				"required": [
					"text"
				],
				"type": "object"
			},
			"MaxContextLengthSetting": {
				"properties": {
					"value": {
						"minimum": 8,
						"type": "integer"
					}
				},
				"required": [
					"value"
				],
				"type": "object"
			},
			"MaxLengthSetting": {
				"properties": {
					"value": {
						"minimum": 1,
						"type": "integer"
					}
				},
				"required": [
					"value"
				],
				"type": "object"
			},
			"ServerBusyError": {
				"properties": {
					"detail": {
						"$ref": "#/components/schemas/BasicError"
					}
				},
				"required": [
					"detail"
				],
				"type": "object"
			},
			"UnauthorizedError": {
				"properties": {
					"detail": {
						"properties": {
							"error": {
								"type": "string"
							},
							"msg": {
								"type": "string"
							},
							"type": {
								"type": "string"
							}
						},
						"required": [
							"error",
							"msg",
							"type"
						],
						"type": "object"
					}
				},
				"required": [
					"detail"
				],
				"type": "object"
			},
			"TranscriptionResult": {
				"properties": {
					"text": {
						"type": "string"
					},
					"words": {
						"type": "array",
						"description": "Forced-aligner word timestamps when requested.",
						"items": {
							"type": "object",
							"properties": {
								"word": {
									"type": "string"
								},
								"start": {
									"type": "number"
								},
								"end": {
									"type": "number"
								}
							},
							"required": [
								"word",
								"start",
								"end"
							]
						}
					},
					"abc": {
						"type": "string",
						"description": "SheetSage2 ABC notation. Present on /api/extra/music/transcribe."
					}
				},
				"required": [
					"text"
				],
				"type": "object"
			},
			"KcppVersion": {
				"properties": {
					"result": {
						"type": "string"
					},
					"version": {
						"type": "string"
					},
					"protected": {
						"type": "boolean"
					},
					"llm": {
						"type": "boolean"
					},
					"txt2img": {
						"type": "boolean"
					},
					"vision": {
						"type": "boolean"
					},
					"audio": {
						"type": "boolean"
					},
					"transcribe": {
						"type": "boolean"
					},
					"multiplayer": {
						"type": "boolean"
					},
					"websearch": {
						"type": "boolean"
					},
					"tts": {
						"type": "boolean"
					},
					"embeddings": {
						"type": "boolean"
					},
					"music": {
						"type": "boolean"
					},
					"musicllm": {
						"type": "boolean"
					},
					"musicfamily": {
						"type": "string",
						"description": "Loaded music backend family, such as acestep, yue2, or none."
					},
					"savedata": {
						"type": "boolean"
					},
					"admin": {
						"type": "integer"
					},
					"router": {
						"type": "boolean"
					},
					"guidance": {
						"type": "boolean"
					},
					"jinja": {
						"type": "boolean"
					},
					"mcp": {
						"type": "boolean"
					},
					"parallelrequests": {
						"type": "integer"
					},
					"defaults_modified": {
						"type": "boolean"
					}
				},
				"required": [
					"version"
				],
				"type": "object"
			},
			"KcppPerf": {
				"properties": {
					"last_process": {
						"type": "number",
						"description": "Last processing time in seconds."
					},
					"last_eval": {
						"type": "number",
						"description": "Last evaluation time in seconds."
					},
					"last_token_count": {
						"type": "integer",
						"description": "Last token count."
					},
					"last_seed": {
						"type": "integer",
						"description": "Last generation seed used."
					},
					"last_draft_success": {
						"type": "integer",
						"description": "Last generation draft successes in tokens."
					},
					"last_draft_failed": {
						"type": "integer",
						"description": "Last generation draft failures in tokens."
					},
					"total_gens": {
						"type": "integer",
						"description": "Total requests generated since startup."
					},
					"total_img_gens": {
						"type": "integer",
						"description": "Total image requests generated since startup."
					},
					"total_tts_gens": {
						"type": "integer",
						"description": "Total tts requests generated since startup."
					},
					"total_transcribe_gens": {
						"type": "integer",
						"description": "Total transcribe requests generated since startup."
					},
					"stop_reason": {
						"type": "integer",
						"description": "Reason the generation stopped. INVALID=-1, OUT_OF_TOKENS=0, EOS_TOKEN_HIT=1, CUSTOM_STOPPER=2"
					},
					"queue": {
						"type": "integer",
						"description": "Length of generation queue."
					},
					"idle": {
						"type": "integer",
						"description": "Status of backend, busy or idle."
					},
					"hordeexitcounter": {
						"type": "integer",
						"description": "Status of embedded horde worker, if applicable. If it's too high, may have crashed."
					},
					"uptime": {
						"type": "number",
						"description": "Seconds that the server has been running for."
					},
					"idletime": {
						"type": "number",
						"description": "Seconds that the server has been inactive for."
					},
					"quiet": {
						"type": "boolean",
						"description": "Is the server in quiet (no logging) mode."
					},
					"last_input_count": {
						"type": "integer",
						"description": "Number of input tokens in the last request."
					},
					"last_process_time": {
						"type": "number",
						"description": "Process time for last request."
					},
					"last_eval_time": {
						"type": "number",
						"description": "Generation time for last request."
					},
					"last_process_speed": {
						"type": "number",
						"description": "Processing speed (tokens/sec)."
					},
					"last_eval_speed": {
						"type": "number",
						"description": "Generation speed (tokens/sec)."
					}
				},
				"type": "object"
			},
			"OpenAIUsage": {
				"type": "object",
				"description": "Token counts reported by KoboldCpp.",
				"properties": {
					"prompt_tokens": {
						"type": "integer"
					},
					"completion_tokens": {
						"type": "integer"
					},
					"total_tokens": {
						"type": "integer"
					}
				},
				"required": [
					"prompt_tokens",
					"completion_tokens",
					"total_tokens"
				]
			},
			"OpenAIFunctionDefinition": {
				"type": "object",
				"properties": {
					"name": {
						"type": "string"
					},
					"description": {
						"type": "string"
					},
					"parameters": {
						"type": "object",
						"description": "JSON Schema describing the function arguments.",
						"additionalProperties": true
					}
				},
				"required": [
					"name",
					"parameters"
				]
			},
			"OpenAITool": {
				"type": "object",
				"description": "Function tool definition. KoboldCpp uses the name, description, and JSON Schema parameters.",
				"properties": {
					"type": {
						"type": "string",
						"enum": [
							"function"
						]
					},
					"function": {
						"$ref": "#/components/schemas/OpenAIFunctionDefinition"
					}
				},
				"required": [
					"type",
					"function"
				]
			},
			"OpenAIToolCall": {
				"type": "object",
				"properties": {
					"id": {
						"type": "string"
					},
					"type": {
						"type": "string",
						"enum": [
							"function"
						]
					},
					"function": {
						"type": "object",
						"properties": {
							"name": {
								"type": "string"
							},
							"arguments": {
								"type": "string",
								"description": "JSON-encoded function arguments."
							}
						},
						"required": [
							"name",
							"arguments"
						]
					}
				},
				"required": [
					"id",
					"type",
					"function"
				]
			},
			"OpenAIToolCallDelta": {
				"type": "object",
				"description": "A partial streamed tool call. Metadata and argument text may arrive in separate chunks.",
				"properties": {
					"index": {
						"type": "integer"
					},
					"id": {
						"type": "string"
					},
					"type": {
						"type": "string",
						"enum": [
							"function"
						]
					},
					"function": {
						"type": "object",
						"properties": {
							"name": {
								"type": "string"
							},
							"arguments": {
								"type": "string"
							}
						}
					}
				},
				"required": [
					"index"
				]
			},
			"OpenAIContentPart": {
				"oneOf": [
					{
						"type": "object",
						"properties": {
							"type": {
								"type": "string",
								"enum": [
									"text"
								]
							},
							"text": {
								"type": "string"
							}
						},
						"required": [
							"type",
							"text"
						]
					},
					{
						"type": "object",
						"description": "KoboldCpp consumes data:image URLs. Remote image URLs are not downloaded.",
						"properties": {
							"type": {
								"type": "string",
								"enum": [
									"image_url"
								]
							},
							"image_url": {
								"type": "object",
								"properties": {
									"url": {
										"type": "string",
										"description": "A data:image/...;base64,... URL."
									}
								},
								"required": [
									"url"
								]
							}
						},
						"required": [
							"type",
							"image_url"
						]
					},
					{
						"type": "object",
						"properties": {
							"type": {
								"type": "string",
								"enum": [
									"input_audio"
								]
							},
							"input_audio": {
								"type": "object",
								"properties": {
									"data": {
										"type": "string",
										"format": "byte"
									},
									"format": {
										"type": "string",
										"example": "wav"
									}
								},
								"required": [
									"data"
								]
							}
						},
						"required": [
							"type",
							"input_audio"
						]
					}
				]
			},
			"OpenAIChatMessage": {
				"type": "object",
				"properties": {
					"role": {
						"type": "string",
						"enum": [
							"system",
							"user",
							"assistant",
							"tool"
						]
					},
					"content": {
						"nullable": true,
						"description": "Text, or OpenAI-style text, image_url, and input_audio content parts.",
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "array",
								"items": {
									"$ref": "#/components/schemas/OpenAIContentPart"
								}
							}
						]
					},
					"tool_calls": {
						"type": "array",
						"items": {
							"$ref": "#/components/schemas/OpenAIToolCall"
						}
					},
					"tool_call_id": {
						"type": "string"
					}
				},
				"required": [
					"role"
				]
			},
			"OpenAICompletionRequest": {
				"type": "object",
				"properties": {
					"model": {
						"type": "string"
					},
					"prompt": {
						"type": "string"
					},
					"max_tokens": {
						"type": "integer",
						"minimum": 1
					},
					"max_completion_tokens": {
						"type": "integer",
						"minimum": 1,
						"description": "Accepted as a fallback when max_tokens is absent."
					},
					"temperature": {
						"type": "number"
					},
					"top_p": {
						"type": "number"
					},
					"presence_penalty": {
						"type": "number"
					},
					"frequency_penalty": {
						"type": "number",
						"description": "Accepted as a fallback alias for presence_penalty."
					},
					"stop": {
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "array",
								"items": {
									"type": "string"
								}
							}
						]
					},
					"seed": {
						"type": "integer"
					},
					"stream": {
						"type": "boolean",
						"default": false
					},
					"logprobs": {
						"description": "Truthy values request log probabilities.",
						"oneOf": [
							{
								"type": "boolean"
							},
							{
								"type": "integer"
							}
						]
					}
				},
				"required": [
					"prompt"
				],
				"additionalProperties": true
			},
			"OpenAICompletionResponse": {
				"type": "object",
				"properties": {
					"id": {
						"type": "string"
					},
					"object": {
						"type": "string",
						"enum": [
							"text_completion"
						]
					},
					"created": {
						"type": "integer"
					},
					"model": {
						"type": "string"
					},
					"choices": {
						"type": "array",
						"items": {
							"type": "object",
							"properties": {
								"text": {
									"type": "string"
								},
								"index": {
									"type": "integer"
								},
								"finish_reason": {
									"type": "string",
									"enum": [
										"stop",
										"length",
										"error"
									]
								},
								"logprobs": {
									"type": "object",
									"nullable": true,
									"additionalProperties": true
								}
							},
							"required": [
								"text",
								"index",
								"finish_reason"
							]
						}
					},
					"usage": {
						"$ref": "#/components/schemas/OpenAIUsage"
					}
				},
				"required": [
					"id",
					"object",
					"choices"
				]
			},
			"OpenAIChatCompletionRequest": {
				"type": "object",
				"properties": {
					"model": {
						"type": "string"
					},
					"messages": {
						"type": "array",
						"items": {
							"$ref": "#/components/schemas/OpenAIChatMessage"
						}
					},
					"max_tokens": {
						"type": "integer",
						"minimum": 1
					},
					"max_completion_tokens": {
						"type": "integer",
						"minimum": 1
					},
					"temperature": {
						"type": "number"
					},
					"top_p": {
						"type": "number"
					},
					"presence_penalty": {
						"type": "number"
					},
					"frequency_penalty": {
						"type": "number",
						"description": "Accepted as a fallback alias for presence_penalty."
					},
					"stop": {
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "array",
								"items": {
									"type": "string"
								}
							}
						]
					},
					"seed": {
						"type": "integer"
					},
					"stream": {
						"type": "boolean",
						"default": false
					},
					"stream_options": {
						"type": "object",
						"properties": {
							"include_usage": {
								"type": "boolean"
							}
						}
					},
					"tools": {
						"type": "array",
						"items": {
							"$ref": "#/components/schemas/OpenAITool"
						}
					},
					"tool_choice": {
						"description": "Supports auto, required, none, an exact function name, or an OpenAI-style function choice object.",
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "object",
								"additionalProperties": true
							}
						]
					},
					"response_format": {
						"type": "object",
						"description": "json_object and json_schema are converted to a generation grammar.",
						"properties": {
							"type": {
								"type": "string",
								"enum": [
									"json_object",
									"json_schema"
								]
							},
							"json_schema": {
								"type": "object",
								"properties": {
									"name": {
										"type": "string"
									},
									"schema": {
										"type": "object",
										"additionalProperties": true
									}
								}
							}
						},
						"required": [
							"type"
						]
					},
					"reasoning_effort": {
						"type": "string",
						"description": "Forwarded to the active Jinja chat template."
					},
					"chat_template_kwargs": {
						"type": "object",
						"additionalProperties": true
					},
					"continue_assistant_turn": {
						"type": "boolean",
						"default": true
					},
					"encapsulate_thinking": {
						"type": "boolean",
						"default": true
					},
					"logprobs": {
						"type": "boolean"
					}
				},
				"required": [
					"messages"
				],
				"additionalProperties": true
			},
			"OpenAIChatCompletionResponse": {
				"type": "object",
				"properties": {
					"id": {
						"type": "string"
					},
					"object": {
						"type": "string",
						"enum": [
							"chat.completion"
						]
					},
					"created": {
						"type": "integer"
					},
					"model": {
						"type": "string"
					},
					"choices": {
						"type": "array",
						"items": {
							"type": "object",
							"properties": {
								"index": {
									"type": "integer"
								},
								"message": {
									"$ref": "#/components/schemas/OpenAIChatMessage"
								},
								"finish_reason": {
									"type": "string",
									"enum": [
										"stop",
										"length",
										"tool_calls",
										"error"
									]
								},
								"logprobs": {
									"type": "object",
									"nullable": true,
									"additionalProperties": true
								}
							},
							"required": [
								"index",
								"message",
								"finish_reason"
							]
						}
					},
					"usage": {
						"$ref": "#/components/schemas/OpenAIUsage"
					}
				},
				"required": [
					"id",
					"object",
					"created",
					"model",
					"choices",
					"usage"
				]
			},
			"OpenAICompletionChunk": {
				"type": "object",
				"description": "JSON value carried by each data: line. The stream ends with data: [DONE].",
				"properties": {
					"id": {
						"type": "string"
					},
					"object": {
						"type": "string",
						"enum": [
							"text_completion"
						]
					},
					"created": {
						"type": "integer"
					},
					"model": {
						"type": "string"
					},
					"choices": {
						"type": "array",
						"items": {
							"type": "object",
							"properties": {
								"index": {
									"type": "integer"
								},
								"text": {
									"type": "string"
								},
								"finish_reason": {
									"type": "string",
									"nullable": true,
									"enum": [
										"stop",
										"length",
										"error"
									]
								},
								"logprobs": {
									"type": "object",
									"nullable": true,
									"additionalProperties": true
								}
							},
							"required": [
								"index",
								"text"
							]
						}
					}
				},
				"required": [
					"id",
					"object",
					"created",
					"model",
					"choices"
				]
			},
			"OpenAIChatCompletionChunk": {
				"type": "object",
				"description": "JSON value carried by each data: line. Tool calls may be buffered and emitted near the end. The stream ends with data: [DONE].",
				"properties": {
					"id": {
						"type": "string"
					},
					"object": {
						"type": "string",
						"enum": [
							"chat.completion.chunk"
						]
					},
					"created": {
						"type": "integer"
					},
					"model": {
						"type": "string"
					},
					"choices": {
						"type": "array",
						"items": {
							"type": "object",
							"properties": {
								"index": {
									"type": "integer"
								},
								"finish_reason": {
									"type": "string",
									"nullable": true,
									"enum": [
										"stop",
										"length",
										"tool_calls",
										"error"
									]
								},
								"delta": {
									"type": "object",
									"properties": {
										"role": {
											"type": "string",
											"enum": [
												"assistant"
											]
										},
										"content": {
											"type": "string"
										},
										"reasoning_content": {
											"type": "string"
										},
										"tool_calls": {
											"type": "array",
											"items": {
												"$ref": "#/components/schemas/OpenAIToolCallDelta"
											}
										}
									}
								},
								"logprobs": {
									"type": "object",
									"nullable": true,
									"additionalProperties": true
								}
							},
							"required": [
								"index",
								"delta"
							]
						}
					},
					"usage": {
						"$ref": "#/components/schemas/OpenAIUsage"
					}
				},
				"required": [
					"id",
					"object",
					"created",
					"model",
					"choices"
				]
			},
			"OpenAIResponsesInputPart": {
				"oneOf": [
					{
						"type": "object",
						"properties": {
							"type": {
								"type": "string",
								"enum": [
									"input_text"
								]
							},
							"text": {
								"type": "string"
							}
						},
						"required": [
							"type",
							"text"
						]
					},
					{
						"type": "object",
						"properties": {
							"type": {
								"type": "string",
								"enum": [
									"input_image"
								]
							},
							"image_url": {
								"type": "string",
								"description": "Use a data:image/...;base64,... URL."
							}
						},
						"required": [
							"type",
							"image_url"
						]
					}
				]
			},
			"OpenAIResponsesInputItem": {
				"type": "object",
				"properties": {
					"role": {
						"type": "string",
						"enum": [
							"system",
							"user",
							"assistant"
						]
					},
					"content": {
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "array",
								"items": {
									"$ref": "#/components/schemas/OpenAIResponsesInputPart"
								}
							}
						]
					}
				},
				"required": [
					"role",
					"content"
				]
			},
			"OpenAIResponsesRequest": {
				"type": "object",
				"description": "Experimental subset converted internally to Chat Completions.",
				"properties": {
					"model": {
						"type": "string"
					},
					"input": {
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "array",
								"items": {
									"oneOf": [
										{
											"type": "string"
										},
										{
											"$ref": "#/components/schemas/OpenAIResponsesInputItem"
										}
									]
								}
							}
						]
					},
					"instructions": {
						"type": "string"
					},
					"max_tokens": {
						"type": "integer",
						"description": "KoboldCpp compatibility field; max_output_tokens is not currently consumed."
					},
					"temperature": {
						"type": "number"
					},
					"top_p": {
						"type": "number"
					},
					"stream": {
						"type": "boolean",
						"default": false
					},
					"tools": {
						"type": "array",
						"items": {
							"$ref": "#/components/schemas/OpenAITool"
						}
					},
					"tool_choice": {
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "object",
								"additionalProperties": true
							}
						]
					}
				},
				"required": [
					"input"
				],
				"additionalProperties": true
			},
			"OpenAIResponseObject": {
				"type": "object",
				"properties": {
					"id": {
						"type": "string"
					},
					"object": {
						"type": "string",
						"enum": [
							"response"
						]
					},
					"created_at": {
						"type": "integer"
					},
					"completed_at": {
						"type": "integer",
						"nullable": true
					},
					"status": {
						"type": "string",
						"enum": [
							"in_progress",
							"completed",
							"failed"
						]
					},
					"model": {
						"type": "string"
					},
					"incomplete_details": {
						"type": "object",
						"nullable": true,
						"additionalProperties": true
					},
					"previous_response_id": {
						"type": "string",
						"nullable": true
					},
					"truncation": {
						"type": "string",
						"enum": [
							"disabled"
						]
					},
					"parallel_tool_calls": {
						"type": "boolean"
					},
					"text": {
						"type": "object",
						"properties": {
							"format": {
								"type": "object",
								"properties": {
									"type": {
										"type": "string",
										"enum": [
											"text"
										]
									}
								}
							},
							"verbosity": {
								"type": "string"
							}
						}
					},
					"instructions": {
						"type": "string",
						"nullable": true
					},
					"error": {
						"type": "object",
						"nullable": true,
						"additionalProperties": true
					},
					"metadata": {
						"type": "object",
						"additionalProperties": true
					},
					"tools": {
						"type": "array",
						"items": {
							"$ref": "#/components/schemas/OpenAITool"
						}
					},
					"tool_choice": {
						"type": "string"
					},
					"background": {
						"type": "boolean"
					},
					"service_tier": {
						"type": "string"
					},
					"safety_identifier": {
						"type": "string",
						"nullable": true
					},
					"prompt_cache_key": {
						"type": "string",
						"nullable": true
					},
					"max_tool_calls": {
						"type": "integer",
						"nullable": true
					},
					"store": {
						"type": "boolean"
					},
					"top_p": {
						"type": "number"
					},
					"max_output_tokens": {
						"type": "integer",
						"nullable": true
					},
					"presence_penalty": {
						"type": "number"
					},
					"frequency_penalty": {
						"type": "number"
					},
					"top_logprobs": {
						"type": "integer"
					},
					"temperature": {
						"type": "number"
					},
					"reasoning": {
						"type": "object",
						"properties": {
							"effort": {
								"type": "string",
								"nullable": true
							},
							"summary": {
								"type": "string",
								"nullable": true
							}
						}
					},
					"output": {
						"type": "array",
						"description": "Assistant message and function_call output items.",
						"items": {
							"oneOf": [
								{
									"type": "object",
									"properties": {
										"type": {
											"type": "string",
											"enum": [
												"message"
											]
										},
										"id": {
											"type": "string"
										},
										"status": {
											"type": "string"
										},
										"role": {
											"type": "string",
											"enum": [
												"assistant"
											]
										},
										"content": {
											"type": "array",
											"items": {
												"type": "object",
												"properties": {
													"type": {
														"type": "string",
														"enum": [
															"output_text"
														]
													},
													"text": {
														"type": "string"
													},
													"annotations": {
														"type": "array",
														"items": {}
													},
													"logprobs": {
														"type": "array",
														"items": {}
													}
												},
												"required": [
													"type",
													"text"
												]
											}
										}
									},
									"required": [
										"type",
										"id",
										"status",
										"role",
										"content"
									]
								},
								{
									"type": "object",
									"properties": {
										"type": {
											"type": "string",
											"enum": [
												"function_call"
											]
										},
										"id": {
											"type": "string"
										},
										"call_id": {
											"type": "string"
										},
										"name": {
											"type": "string"
										},
										"arguments": {
											"type": "string"
										},
										"status": {
											"type": "string"
										}
									},
									"required": [
										"type",
										"id",
										"call_id",
										"name",
										"arguments",
										"status"
									]
								}
							]
						}
					},
					"usage": {
						"type": "object",
						"nullable": true,
						"properties": {
							"input_tokens": {
								"type": "integer"
							},
							"output_tokens": {
								"type": "integer"
							},
							"total_tokens": {
								"type": "integer"
							}
						},
						"required": [
							"input_tokens",
							"output_tokens",
							"total_tokens"
						]
					}
				},
				"required": [
					"id",
					"object",
					"created_at",
					"status",
					"model",
					"output",
					"usage"
				]
			},
			"OpenAIErrorResponse": {
				"type": "object",
				"properties": {
					"error": {
						"type": "object",
						"properties": {
							"message": {
								"type": "string"
							},
							"type": {
								"type": "string"
							},
							"param": {
								"type": "string",
								"nullable": true
							},
							"code": {
								"type": "string"
							}
						},
						"required": [
							"message",
							"type",
							"code"
						]
					}
				},
				"required": [
					"error"
				]
			},
			"OpenAIResponseStreamEvent": {
				"type": "object",
				"description": "Data object for one Responses SSE event. KoboldCpp emits response.created, response.output_item.added, response.content_part.added, response.output_text.delta, response.output_text.done, response.output_item.done, and response.completed.",
				"properties": {
					"type": {
						"type": "string",
						"enum": [
							"response.created",
							"response.output_item.added",
							"response.content_part.added",
							"response.output_text.delta",
							"response.output_text.done",
							"response.output_item.done",
							"response.completed"
						]
					},
					"sequence_number": {
						"type": "integer"
					},
					"response": {
						"$ref": "#/components/schemas/OpenAIResponseObject"
					},
					"output_index": {
						"type": "integer"
					},
					"content_index": {
						"type": "integer"
					},
					"item_id": {
						"type": "string"
					},
					"delta": {
						"type": "string"
					},
					"text": {
						"type": "string"
					},
					"item": {
						"type": "object",
						"additionalProperties": true
					},
					"part": {
						"type": "object",
						"additionalProperties": true
					},
					"logprobs": {
						"type": "array",
						"items": {}
					}
				},
				"required": [
					"type",
					"sequence_number"
				]
			},
			"OpenAIImageRequest": {
				"type": "object",
				"properties": {
					"model": {
						"type": "string"
					},
					"prompt": {
						"type": "string"
					},
					"size": {
						"type": "string",
						"example": "512x512"
					},
					"response_format": {
						"type": "string",
						"enum": [
							"b64_json"
						]
					},
					"n": {
						"type": "integer",
						"description": "Accepted, but KoboldCpp returns one image."
					}
				},
				"required": [
					"prompt"
				],
				"additionalProperties": true
			},
			"OpenAIImageEditRequest": {
				"type": "object",
				"properties": {
					"image": {
						"type": "string",
						"format": "binary"
					},
					"mask": {
						"type": "string",
						"format": "binary"
					},
					"prompt": {
						"type": "string"
					},
					"model": {
						"type": "string"
					},
					"size": {
						"type": "string"
					},
					"response_format": {
						"type": "string",
						"enum": [
							"b64_json"
						]
					}
				},
				"required": [
					"image",
					"prompt"
				],
				"additionalProperties": true
			},
			"OpenAIImageResponse": {
				"type": "object",
				"properties": {
					"created": {
						"type": "integer"
					},
					"data": {
						"type": "array",
						"items": {
							"type": "object",
							"properties": {
								"b64_json": {
									"type": "string",
									"format": "byte"
								}
							},
							"required": [
								"b64_json"
							]
						}
					},
					"background": {
						"type": "string"
					},
					"output_format": {
						"type": "string"
					},
					"size": {
						"type": "string"
					},
					"quality": {
						"type": "string"
					}
				},
				"required": [
					"created",
					"data"
				]
			},
			"OpenAIModelList": {
				"type": "object",
				"properties": {
					"object": {
						"type": "string",
						"enum": [
							"list"
						]
					},
					"data": {
						"type": "array",
						"items": {
							"type": "object",
							"properties": {
								"id": {
									"type": "string"
								},
								"object": {
									"type": "string",
									"enum": [
										"model"
									]
								},
								"created": {
									"type": "integer"
								},
								"owned_by": {
									"type": "string"
								},
								"status": {
									"type": "object",
									"additionalProperties": true
								},
								"permission": {
									"type": "array",
									"items": {
										"type": "object"
									}
								},
								"root": {
									"type": "string"
								}
							},
							"required": [
								"id",
								"object",
								"created",
								"owned_by"
							]
						}
					}
				},
				"required": [
					"object",
					"data"
				]
			},
			"OpenAITranscriptionRequest": {
				"type": "object",
				"properties": {
					"file": {
						"type": "string",
						"format": "binary"
					},
					"model": {
						"type": "string"
					},
					"prompt": {
						"type": "string"
					},
					"language": {
						"type": "string",
						"description": "Language code, or auto when omitted. Required when transcript is supplied."
					},
					"transcript": {
						"type": "string",
						"description": "Known transcript to align directly against the audio with the configured forced aligner, bypassing ASR."
					},
					"return_timestamps": {
						"type": "boolean",
						"description": "Adds word timestamps from the configured forced aligner. Requires --transcribealigner."
					}
				},
				"required": [
					"file"
				]
			},
			"OpenAISpeechRequest": {
				"type": "object",
				"description": "OpenAI-compatible speech input. KoboldCpp also accepts the KoboldCpp TTS fields and model-specific Audio.cpp options listed below.",
				"properties": {
					"model": {
						"type": "string"
					},
					"input": {
						"type": "string"
					},
					"voice": {
						"type": "string",
						"description": "Built-in or custom voice name. A WAV/MP3 filename can refer to a voice loaded with --ttsdir; OpenAI names such as alloy are also accepted."
					},
					"speaker_wav": {
						"type": "string",
						"description": "Compatibility alias for voice."
					},
					"speaker_json": {
						"type": "string",
						"description": "Custom speaker JSON for compatible TTS models."
					},
					"response_format": {
						"type": "string",
						"enum": [
							"wav",
							"mp3"
						],
						"default": "wav"
					},
					"use_mp3": {
						"type": "boolean",
						"description": "KoboldCpp alias for requesting MP3 output."
					},
					"seed": {
						"type": "integer",
						"description": "Audio generation seed."
					},
					"language": {
						"type": "string"
					},
					"instructions": {
						"type": "string",
						"description": "Some models use this as a voice/narration instruction."
					},
					"reference_text": {
						"type": "string",
						"description": "Transcript of the reference voice clip when required by the loaded model."
					}
				},
				"required": [
					"input"
				],
				"additionalProperties": true
			},
			"OpenAIVoiceList": {
				"type": "object",
				"properties": {
					"status": {
						"type": "string",
						"enum": [
							"ok"
						]
					},
					"voices": {
						"type": "array",
						"items": {
							"type": "string"
						}
					}
				},
				"required": [
					"status",
					"voices"
				]
			},
			"OpenAIEmbeddingRequest": {
				"type": "object",
				"properties": {
					"model": {
						"type": "string"
					},
					"input": {
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "array",
								"items": {
									"type": "string"
								}
							}
						]
					},
					"encoding_format": {
						"type": "string",
						"enum": [
							"float",
							"base64"
						]
					},
					"truncate": {
						"type": "boolean",
						"default": true
					}
				},
				"required": [
					"input"
				]
			},
			"OpenAIEmbeddingResponse": {
				"type": "object",
				"properties": {
					"object": {
						"type": "string",
						"enum": [
							"list"
						]
					},
					"data": {
						"type": "array",
						"items": {
							"type": "object",
							"properties": {
								"object": {
									"type": "string",
									"enum": [
										"embedding"
									]
								},
								"index": {
									"type": "integer"
								},
								"embedding": {
									"oneOf": [
										{
											"type": "array",
											"items": {
												"type": "number",
												"format": "float"
											}
										},
										{
											"type": "string",
											"format": "byte"
										}
									]
								}
							},
							"required": [
								"object",
								"index",
								"embedding"
							]
						}
					},
					"model": {
						"type": "string"
					},
					"usage": {
						"type": "object",
						"properties": {
							"prompt_tokens": {
								"type": "integer"
							},
							"total_tokens": {
								"type": "integer"
							}
						},
						"required": [
							"prompt_tokens",
							"total_tokens"
						]
					}
				},
				"required": [
					"object",
					"data",
					"model",
					"usage"
				]
			},
			"AnthropicSource": {
				"type": "object",
				"description": "Media/document source. Images and audio are usable as model media when supplied as base64; URL image sources are not downloaded. Document text/data is inserted as text.",
				"properties": {
					"type": {
						"type": "string",
						"enum": [
							"base64",
							"url",
							"text"
						]
					},
					"media_type": {
						"type": "string"
					},
					"data": {
						"type": "string"
					},
					"url": {
						"type": "string"
					},
					"text": {
						"type": "string"
					}
				},
				"required": [
					"type"
				]
			},
			"AnthropicContentBlock": {
				"oneOf": [
					{
						"type": "object",
						"properties": {
							"type": {
								"type": "string",
								"enum": [
									"text"
								]
							},
							"text": {
								"type": "string"
							}
						},
						"required": [
							"type",
							"text"
						]
					},
					{
						"type": "object",
						"properties": {
							"type": {
								"type": "string",
								"enum": [
									"image",
									"audio",
									"document"
								]
							},
							"source": {
								"$ref": "#/components/schemas/AnthropicSource"
							}
						},
						"required": [
							"type",
							"source"
						]
					},
					{
						"type": "object",
						"properties": {
							"type": {
								"type": "string",
								"enum": [
									"tool_use"
								]
							},
							"id": {
								"type": "string"
							},
							"name": {
								"type": "string"
							},
							"input": {
								"type": "object",
								"additionalProperties": true
							}
						},
						"required": [
							"type",
							"id",
							"name",
							"input"
						]
					},
					{
						"type": "object",
						"properties": {
							"type": {
								"type": "string",
								"enum": [
									"tool_result"
								]
							},
							"tool_use_id": {
								"type": "string"
							},
							"content": {
								"oneOf": [
									{
										"type": "string"
									},
									{
										"type": "array",
										"items": {
											"type": "object",
											"additionalProperties": true
										}
									}
								]
							},
							"is_error": {
								"type": "boolean"
							}
						},
						"required": [
							"type",
							"tool_use_id",
							"content"
						]
					}
				]
			},
			"AnthropicMessage": {
				"type": "object",
				"properties": {
					"role": {
						"type": "string",
						"enum": [
							"user",
							"assistant"
						]
					},
					"content": {
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "array",
								"items": {
									"$ref": "#/components/schemas/AnthropicContentBlock"
								}
							}
						]
					}
				},
				"required": [
					"role",
					"content"
				]
			},
			"AnthropicTool": {
				"type": "object",
				"properties": {
					"name": {
						"type": "string"
					},
					"description": {
						"type": "string"
					},
					"input_schema": {
						"type": "object",
						"additionalProperties": true
					}
				},
				"required": [
					"name",
					"input_schema"
				]
			},
			"AnthropicMessagesRequest": {
				"type": "object",
				"properties": {
					"model": {
						"type": "string",
						"description": "Compatibility model identifier. KoboldCpp generates with the active text model and reports that model's name in the response."
					},
					"messages": {
						"type": "array",
						"items": {
							"$ref": "#/components/schemas/AnthropicMessage"
						}
					},
					"system": {
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "array",
								"items": {
									"type": "object",
									"properties": {
										"type": {
											"type": "string",
											"enum": [
												"text"
											]
										},
										"text": {
											"type": "string"
										}
									},
									"required": [
										"type",
										"text"
									]
								}
							}
						]
					},
					"max_tokens": {
						"type": "integer",
						"minimum": 1
					},
					"temperature": {
						"type": "number"
					},
					"top_p": {
						"type": "number"
					},
					"top_k": {
						"type": "integer"
					},
					"stop_sequences": {
						"type": "array",
						"items": {
							"type": "string"
						},
						"description": "Anthropic-compatible stop strings."
					},
					"stop": {
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "array",
								"items": {
									"type": "string"
								}
							}
						]
					},
					"stream": {
						"type": "boolean",
						"default": false
					},
					"tools": {
						"type": "array",
						"items": {
							"$ref": "#/components/schemas/AnthropicTool"
						}
					},
					"tool_choice": {
						"description": "Supports auto, any, none, an exact function name, or an OpenAI-style function choice object. Native Anthropic objects with type auto, any, none, or tool are accepted.",
						"oneOf": [
							{
								"type": "string"
							},
							{
								"type": "object",
								"additionalProperties": true
							}
						]
					},
					"encapsulate_thinking": {
						"type": "boolean",
						"default": true
					}
				},
				"required": [
					"messages",
					"max_tokens"
				],
				"additionalProperties": true
			},
			"AnthropicMessagesResponse": {
				"type": "object",
				"properties": {
					"id": {
						"type": "string"
					},
					"type": {
						"type": "string",
						"enum": [
							"message"
						]
					},
					"role": {
						"type": "string",
						"enum": [
							"assistant"
						]
					},
					"model": {
						"type": "string"
					},
					"content": {
						"type": "array",
						"items": {
							"oneOf": [
								{
									"type": "object",
									"properties": {
										"type": {
											"type": "string",
											"enum": [
												"text"
											]
										},
										"text": {
											"type": "string"
										}
									},
									"required": [
										"type",
										"text"
									]
								},
								{
									"type": "object",
									"properties": {
										"type": {
											"type": "string",
											"enum": [
												"thinking"
											]
										},
										"thinking": {
											"type": "string"
										}
									},
									"required": [
										"type",
										"thinking"
									]
								},
								{
									"type": "object",
									"properties": {
										"type": {
											"type": "string",
											"enum": [
												"tool_use"
											]
										},
										"id": {
											"type": "string"
										},
										"name": {
											"type": "string"
										},
										"input": {
											"type": "object",
											"additionalProperties": true
										}
									},
									"required": [
										"type",
										"id",
										"name",
										"input"
									]
								}
							]
						}
					},
					"stop_reason": {
						"type": "string",
						"enum": [
							"end_turn",
							"max_tokens",
							"stop_sequence",
							"tool_use"
						]
					},
					"stop_sequence": {
						"type": "string",
						"nullable": true
					},
					"usage": {
						"type": "object",
						"properties": {
							"input_tokens": {
								"type": "integer"
							},
							"output_tokens": {
								"type": "integer"
							}
						},
						"required": [
							"input_tokens",
							"output_tokens"
						]
					}
				},
				"required": [
					"id",
					"type",
					"role",
					"model",
					"content",
					"stop_reason",
					"usage"
				]
			},
			"AnthropicStreamEvent": {
				"type": "object",
				"description": "Data object for an Anthropic-style SSE event. The SSE event name matches type.",
				"properties": {
					"type": {
						"type": "string",
						"enum": [
							"message_start",
							"content_block_start",
							"content_block_delta",
							"content_block_stop",
							"message_delta",
							"message_stop"
						]
					},
					"message": {
						"type": "object",
						"description": "Partial message supplied by message_start.",
						"properties": {
							"type": {
								"type": "string",
								"enum": [
									"message"
								]
							},
							"id": {
								"type": "string"
							},
							"role": {
								"type": "string",
								"enum": [
									"assistant"
								]
							},
							"model": {
								"type": "string"
							},
							"content": {
								"type": "array",
								"items": {}
							},
							"stop_reason": {
								"type": "string",
								"nullable": true
							},
							"stop_sequence": {
								"type": "string",
								"nullable": true
							},
							"usage": {
								"type": "object",
								"properties": {
									"input_tokens": {
										"type": "integer"
									},
									"output_tokens": {
										"type": "integer"
									}
								}
							}
						},
						"required": [
							"type",
							"id",
							"role",
							"model",
							"content",
							"stop_reason",
							"stop_sequence",
							"usage"
						]
					},
					"index": {
						"type": "integer"
					},
					"content_block": {
						"type": "object",
						"additionalProperties": true
					},
					"delta": {
						"type": "object",
						"description": "text_delta, thinking_delta, input_json_delta, or final stop information.",
						"additionalProperties": true
					},
					"usage": {
						"type": "object",
						"properties": {
							"input_tokens": {
								"type": "integer"
							},
							"output_tokens": {
								"type": "integer"
							}
						}
					}
				},
				"required": [
					"type"
				]
			}
		},
		"securitySchemes": {
			"BearerAuth": {
				"type": "http",
				"scheme": "bearer",
				"bearerFormat": "KoboldCpp server password",
				"description": "Required on protected endpoints when KoboldCpp is launched with --password. Send the password as `Authorization: Bearer <password>`. If both passwords are configured, --adminpassword is also accepted as an alternative on these regular protected endpoints."
			},
			"AdminBearerAuth": {
				"type": "http",
				"scheme": "bearer",
				"bearerFormat": "KoboldCpp admin password",
				"description": "Used by /api/admin endpoints when --adminpassword is configured. Send it as `Authorization: Bearer <adminpassword>`. Admin endpoints also require the relevant admin mode options such as --admin and --admindir. Failed admin authentication currently returns an empty or unsuccessful HTTP 200 response rather than HTTP 401."
			}
		},
		"responses": {
			"Unauthorized": {
				"description": "The server was launched with password protection and the Bearer token is missing or invalid.",
				"content": {
					"application/json": {
						"example": {
							"detail": {
								"error": "Unauthorized",
								"msg": "Authentication key is missing or invalid.",
								"type": "unauthorized"
							}
						},
						"schema": {
							"$ref": "#/components/schemas/UnauthorizedError"
						}
					}
				}
			}
		}
	},
	"info": {
		"title": "KoboldCpp API",
		"description": "For swagger.json, <a href=\"?json=1\">click here</a> or use <a href=\"https://lite.koboldai.net/koboldcpp_api.json\">online version</a>.",
		"version": "2026.11.01"
	},
	"openapi": "3.0.3",
	"paths": {
		"/v1/completions": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Generates text continuations given a prompt. Please refer to OpenAI documentation",
				"description": "Generates text continuations given a prompt.\n\nThis is an OpenAI compatibility endpoint.\n\n Please refer to OpenAI documentation at [https://developers.openai.com/api/reference/resources/completions/methods/create](https://developers.openai.com/api/reference/resources/completions/methods/create). All KoboldCpp samplers are supported, please refer to /api/v1/generate for more details.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"model": "kcpp",
								"prompt": "Hi, my name is Kobo and",
								"temperature": 0.8,
								"max_tokens": 64
							},
							"schema": {
								"$ref": "#/components/schemas/OpenAICompletionRequest"
							}
						}
					},
					"required": true
				},
				"tags": [
					"v1"
				],
				"responses": {
					"200": {
						"description": "Completion response, or an SSE stream when stream=true.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/OpenAICompletionResponse"
								}
							},
							"text/event-stream": {
								"schema": {
									"oneOf": [
										{
											"$ref": "#/components/schemas/OpenAICompletionChunk"
										},
										{
											"$ref": "#/components/schemas/OpenAIErrorResponse"
										}
									],
									"description": "Each data payload is a completion chunk or, after headers have been committed, an error object. The stream terminates with [DONE]."
								}
							}
						}
					},
					"401": {
						"$ref": "#/components/responses/Unauthorized"
					},
					"500": {
						"description": "The backend failed to generate a completion.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/OpenAIErrorResponse"
								}
							}
						}
					}
				}
			}
		},
		"/v1/chat/completions": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Generates a response from a list of messages. Please refer to OpenAI documentation",
				"description": "Given a list of messages comprising a conversation, the model will return a response.\n\n This is an OpenAI compatibility endpoint.\n\n Please refer to OpenAI documentation at [https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create). All KoboldCpp samplers are supported, please refer to /api/v1/generate for more details.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"model": "kcpp",
								"messages": [
									{
										"role": "system",
										"content": "You are a helpful assistant."
									},
									{
										"role": "user",
										"content": "Tell me a joke about Kobolds."
									}
								],
								"temperature": 0.7
							},
							"schema": {
								"$ref": "#/components/schemas/OpenAIChatCompletionRequest"
							}
						}
					},
					"required": true
				},
				"tags": [
					"v1"
				],
				"responses": {
					"200": {
						"description": "Chat completion, or an SSE stream when stream=true.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/OpenAIChatCompletionResponse"
								}
							},
							"text/event-stream": {
								"schema": {
									"oneOf": [
										{
											"$ref": "#/components/schemas/OpenAIChatCompletionChunk"
										},
										{
											"$ref": "#/components/schemas/OpenAIErrorResponse"
										}
									],
									"description": "Each data payload is a chat chunk or, after headers have been committed, an error object. The stream terminates with [DONE]."
								}
							}
						}
					},
					"401": {
						"$ref": "#/components/responses/Unauthorized"
					},
					"500": {
						"description": "The backend failed to generate a chat completion.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/OpenAIErrorResponse"
								}
							}
						}
					}
				}
			}
		},
		"/v1/responses": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Emulates OpenAI Responses API. Very experimental, not recommended (use chat completions instead). Please refer to OpenAI documentation",
				"description": "Emulates OpenAI Responses API.\n\n This is an OpenAI compatibility endpoint.\n\n Please refer to OpenAI documentation at [https://developers.openai.com/api/reference/resources/responses](https://developers.openai.com/api/reference/resources/responses). All KoboldCpp samplers are supported, please refer to /api/v1/generate for more details.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"model": "kcpp",
								"input": "Tell me a joke about Kobolds."
							},
							"schema": {
								"$ref": "#/components/schemas/OpenAIResponsesRequest"
							}
						}
					},
					"required": true
				},
				"tags": [
					"v1"
				],
				"responses": {
					"200": {
						"description": "Response object, or named SSE events when stream=true.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/OpenAIResponseObject"
								}
							},
							"text/event-stream": {
								"schema": {
									"$ref": "#/components/schemas/OpenAIResponseStreamEvent"
								}
							}
						}
					},
					"401": {
						"$ref": "#/components/responses/Unauthorized"
					}
				}
			}
		},
		"/v1/images/generations": {
			"post": {
				"summary": "Generates images from a text prompt. Please refer to OpenAI documentation",
				"description": "Creates images from a text prompt.\n\n This is an OpenAI compatibility endpoint.\n\n Please refer to OpenAI documentation at [https://developers.openai.com/docs/api-reference/images/create](https://developers.openai.com/docs/api-reference/images/create).",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"model": "kcpp",
								"prompt": "picture of a kobold, high quality HD render",
								"n": 1,
								"size": "512x512",
								"response_format": "b64_json"
							},
							"schema": {
								"$ref": "#/components/schemas/OpenAIImageRequest"
							}
						}
					},
					"required": true
				},
				"tags": [
					"v1"
				],
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"created": 1710000000,
									"data": [
										{
											"b64_json": "base64_image_data"
										}
									]
								},
								"schema": {
									"$ref": "#/components/schemas/OpenAIImageResponse"
								}
							}
						},
						"description": "Successful request"
					}
				}
			}
		},
		"/v1/images/edits": {
			"post": {
				"summary": "Edit an image using the OpenAI-compatible multipart format",
				"description": "Requires a loaded image model. Repeated image or image[] fields and an optional mask are accepted. KoboldCpp returns one base64 PNG image and intentionally bypasses --password authentication.",
				"requestBody": {
					"required": true,
					"content": {
						"multipart/form-data": {
							"schema": {
								"$ref": "#/components/schemas/OpenAIImageEditRequest"
							}
						}
					}
				},
				"tags": [
					"v1"
				],
				"responses": {
					"200": {
						"description": "Edited image.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/OpenAIImageResponse"
								}
							}
						}
					}
				}
			}
		},
		"/v1/models": {
			"get": {
				"summary": "List and describe the various models available in the API. Please refer to OpenAI documentation",
				"description": "List and describe the various models available in the API.\n\n This is an OpenAI compatibility endpoint.\n\n Please refer to OpenAI documentation at [https://developers.openai.com/docs/api-reference/models](https://developers.openai.com/docs/api-reference/models)",
				"tags": [
					"v1"
				],
				"responses": {
					"200": {
						"description": "Model list.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/OpenAIModelList"
								}
							}
						}
					}
				}
			}
		},
		"/v1/audio/transcriptions": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Create an OpenAI-compatible audio transcription",
				"description": "Accepts a multipart audio file plus optional prompt and language. Uses the loaded Whisper or Audio.cpp ASR model, or an audio-capable multimodal projector when no transcription model is loaded. Set return_timestamps=true with Qwen3-ASR and --transcribealigner to include word timestamps.",
				"requestBody": {
					"required": true,
					"content": {
						"multipart/form-data": {
							"schema": {
								"$ref": "#/components/schemas/OpenAITranscriptionRequest"
							}
						}
					}
				},
				"tags": [
					"v1"
				],
				"responses": {
					"200": {
						"description": "Transcription text and optional word timestamps.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/TranscriptionResult"
								}
							}
						}
					},
					"401": {
						"$ref": "#/components/responses/Unauthorized"
					}
				}
			}
		},
		"/v1/audio/speech": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Generates Text-To-Speech audio from input text. Please refer to OpenAI documentation",
				"description": "Generates Text-To-Speech audio from input text.\n\n This is an OpenAI compatibility endpoint.\n\n Please refer to OpenAI documentation at [https://developers.openai.com/docs/api-reference/audio/createSpeech](https://developers.openai.com/docs/api-reference/audio/createSpeech)",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"model": "kcpp",
								"input": "Hello, my name is Kobold and I love to play.",
								"voice": "alloy"
							},
							"schema": {
								"$ref": "#/components/schemas/OpenAISpeechRequest"
							}
						}
					},
					"required": true
				},
				"tags": [
					"v1"
				],
				"responses": {
					"200": {
						"description": "Generated audio bytes.",
						"content": {
							"audio/wav": {
								"schema": {
									"type": "string",
									"format": "binary"
								}
							},
							"audio/mpeg": {
								"schema": {
									"type": "string",
									"format": "binary"
								}
							}
						}
					},
					"401": {
						"$ref": "#/components/responses/Unauthorized"
					}
				}
			}
		},
		"/v1/audio/voices": {
			"get": {
				"summary": "List voices available to the OpenAI-compatible speech endpoint",
				"description": "KoboldCpp extension used by compatible TTS clients. This public endpoint does not enforce --password.",
				"tags": [
					"v1"
				],
				"responses": {
					"200": {
						"description": "Available voice names.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/OpenAIVoiceList"
								}
							}
						}
					}
				}
			}
		},
		"/v1/embeddings": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Creates an embedding vector representing the input text. Please refer to OpenAI documentation",
				"description": "Creates an embedding vector representing the input text.\n\nThis is an OpenAI compatibility endpoint.\n\n Please refer to OpenAI documentation at [https://developers.openai.com/docs/api-reference/embeddings/create](https://developers.openai.com/docs/api-reference/embeddings/create)",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"model": "kcpp",
								"input": "Niko the Kobold is in town today.",
								"truncate": true
							},
							"schema": {
								"$ref": "#/components/schemas/OpenAIEmbeddingRequest"
							}
						}
					},
					"required": true
				},
				"tags": [
					"v1"
				],
				"responses": {
					"200": {
						"description": "Embedding list.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/OpenAIEmbeddingResponse"
								}
							}
						}
					},
					"401": {
						"$ref": "#/components/responses/Unauthorized"
					}
				}
			}
		},
		"/v1/messages": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Creates a message using the Anthropic Messages API format",
				"description": "Given a structured list of input messages, a system prompt, and required tokens parameter, the model will return a response. This follows the native Anthropic Messages payload style.",
				"tags": [
					"v1"
				],
				"parameters": [
					{
						"name": "x-api-key",
						"in": "header",
						"required": false,
						"description": "Optional Anthropic compatibility header. KoboldCpp does not validate this header; when --password is configured, authenticate with Authorization: Bearer <password> instead.",
						"schema": {
							"type": "string"
						}
					},
					{
						"name": "anthropic-version",
						"in": "header",
						"required": false,
						"description": "Accepted for Anthropic client compatibility but not inspected or validated by KoboldCpp.",
						"schema": {
							"type": "string",
							"default": "2023-06-01"
						}
					}
				],
				"requestBody": {
					"required": true,
					"content": {
						"application/json": {
							"example": {
								"model": "claude-3-5-sonnet-20241022",
								"max_tokens": 1024,
								"system": "You are a helpful assistant.",
								"messages": [
									{
										"role": "user",
										"content": "Tell me a joke about Kobolds."
									}
								],
								"temperature": 0.7
							},
							"schema": {
								"$ref": "#/components/schemas/AnthropicMessagesRequest"
							}
						}
					}
				},
				"responses": {
					"200": {
						"description": "Message response, or named Anthropic-style SSE events when stream=true.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/AnthropicMessagesResponse"
								}
							},
							"text/event-stream": {
								"schema": {
									"$ref": "#/components/schemas/AnthropicStreamEvent"
								}
							}
						}
					},
					"401": {
						"$ref": "#/components/responses/Unauthorized"
					}
				}
			}
		},
		"/v1/completion": {
			"$ref": "#/paths/~1v1~1completions"
		},
		"/completions": {
			"$ref": "#/paths/~1v1~1completions"
		},
		"/chat/completions": {
			"$ref": "#/paths/~1v1~1chat~1completions"
		},
		"/responses": {
			"$ref": "#/paths/~1v1~1responses"
		},
		"/images/generations": {
			"$ref": "#/paths/~1v1~1images~1generations"
		},
		"/images/edits": {
			"$ref": "#/paths/~1v1~1images~1edits"
		},
		"/models": {
			"$ref": "#/paths/~1v1~1models"
		},
		"/audio/transcriptions": {
			"$ref": "#/paths/~1v1~1audio~1transcriptions"
		},
		"/audio/speech": {
			"$ref": "#/paths/~1v1~1audio~1speech"
		},
		"/audio/voices": {
			"$ref": "#/paths/~1v1~1audio~1voices"
		},
		"/messages": {
			"$ref": "#/paths/~1v1~1messages"
		},
		"/api/latest/generate": {
			"$ref": "#/paths/~1api~1v1~1generate"
		},
		"/api/latest/model": {
			"$ref": "#/paths/~1api~1v1~1model"
		},
		"/api/latest/config/max_length": {
			"$ref": "#/paths/~1api~1v1~1config~1max_length"
		},
		"/api/latest/config/max_context_length": {
			"$ref": "#/paths/~1api~1v1~1config~1max_context_length"
		},
		"/api/latest/info/version": {
			"$ref": "#/paths/~1api~1v1~1info~1version"
		},
		"/api/generate": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Generate text using the Ollama API format",
				"description": "A basic Ollama-compatible generation endpoint. Streaming is enabled by default and returns newline-delimited JSON objects, not SSE events.",
				"tags": [
					"ollama"
				],
				"requestBody": {
					"required": true,
					"content": {
						"application/json": {
							"schema": {
								"type": "object",
								"properties": {
									"model": {
										"type": "string",
										"description": "Accepted for compatibility; KoboldCpp uses the active model."
									},
									"prompt": {
										"type": "string"
									},
									"system": {
										"type": "string"
									},
									"context": {
										"type": "array",
										"items": {
											"type": "integer"
										}
									},
									"stream": {
										"type": "boolean",
										"default": true
									},
									"stop": {
										"type": "array",
										"items": {
											"type": "string"
										}
									},
									"options": {
										"type": "object",
										"properties": {
											"num_predict": {
												"type": "integer"
											},
											"num_ctx": {
												"type": "integer"
											},
											"temperature": {
												"type": "number"
											},
											"top_k": {
												"type": "integer"
											},
											"top_p": {
												"type": "number"
											},
											"seed": {
												"type": "integer"
											},
											"stop": {
												"type": "array",
												"items": {
													"type": "string"
												}
											}
										}
									}
								},
								"required": [
									"prompt"
								]
							}
						}
					}
				},
				"responses": {
					"200": {
						"description": "A single JSON response when stream=false, or one JSON object per line when stream=true.",
						"content": {
							"application/json": {
								"schema": {
									"type": "object",
									"properties": {
										"model": {
											"type": "string"
										},
										"created_at": {
											"type": "string"
										},
										"response": {
											"type": "string"
										},
										"done": {
											"type": "boolean"
										},
										"done_reason": {
											"type": "string"
										},
										"context": {
											"type": "array",
											"items": {
												"type": "integer"
											}
										}
									}
								}
							},
							"application/x-ndjson": {
								"schema": {
									"type": "object",
									"additionalProperties": true
								}
							}
						}
					},
					"401": {
						"$ref": "#/components/responses/Unauthorized"
					},
					"503": {
						"description": "Server is busy.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/ServerBusyError"
								}
							}
						}
					}
				}
			}
		},
		"/api/chat": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Generate a chat response using the Ollama API format",
				"description": "A basic Ollama-compatible chat endpoint. Streaming is enabled by default and returns newline-delimited JSON objects. Text messages, base64 images, and function tools are supported.",
				"tags": [
					"ollama"
				],
				"requestBody": {
					"required": true,
					"content": {
						"application/json": {
							"schema": {
								"type": "object",
								"properties": {
									"model": {
										"type": "string",
										"description": "Accepted for compatibility; KoboldCpp uses the active model."
									},
									"messages": {
										"type": "array",
										"items": {
											"type": "object",
											"properties": {
												"role": {
													"type": "string",
													"enum": [
														"system",
														"user",
														"assistant",
														"tool"
													]
												},
												"content": {
													"type": "string"
												},
												"images": {
													"type": "array",
													"items": {
														"type": "string"
													}
												},
												"tool_calls": {
													"type": "array",
													"items": {
														"type": "object",
														"additionalProperties": true
													}
												}
											},
											"required": [
												"role",
												"content"
											]
										}
									},
									"tools": {
										"type": "array",
										"items": {
											"type": "object",
											"additionalProperties": true
										},
										"description": "Ollama/OpenAI-style function tool definitions."
									},
									"stream": {
										"type": "boolean",
										"default": true
									}
								},
								"required": [
									"messages"
								]
							}
						}
					}
				},
				"responses": {
					"200": {
						"description": "A single JSON response when stream=false, or one JSON object per line when stream=true.",
						"content": {
							"application/json": {
								"schema": {
									"type": "object",
									"properties": {
										"model": {
											"type": "string"
										},
										"created_at": {
											"type": "string"
										},
										"message": {
											"type": "object",
											"properties": {
												"role": {
													"type": "string",
													"enum": [
														"assistant"
													]
												},
												"content": {
													"type": "string"
												},
												"tool_calls": {
													"type": "array",
													"items": {
														"type": "object",
														"additionalProperties": true
													}
												}
											}
										},
										"done": {
											"type": "boolean"
										},
										"done_reason": {
											"type": "string"
										}
									}
								}
							},
							"application/x-ndjson": {
								"schema": {
									"type": "object",
									"additionalProperties": true
								}
							}
						}
					},
					"401": {
						"$ref": "#/components/responses/Unauthorized"
					},
					"503": {
						"description": "Server is busy.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/ServerBusyError"
								}
							}
						}
					}
				}
			}
		},
		"/api/tags": {
			"get": {
				"summary": "List the active model in Ollama format",
				"description": "Returns synthetic Ollama model metadata for the active KoboldCpp model.",
				"tags": [
					"ollama"
				],
				"responses": {
					"200": {
						"description": "Ollama-compatible model list.",
						"content": {
							"application/json": {
								"schema": {
									"type": "object",
									"properties": {
										"models": {
											"type": "array",
											"items": {
												"type": "object",
												"properties": {
													"name": {
														"type": "string"
													},
													"model": {
														"type": "string"
													},
													"modified_at": {
														"type": "string"
													},
													"expires_at": {
														"type": "string"
													},
													"size": {
														"type": "integer"
													},
													"size_vram": {
														"type": "integer"
													},
													"digest": {
														"type": "string"
													},
													"details": {
														"type": "object",
														"additionalProperties": true
													}
												}
											}
										}
									},
									"required": [
										"models"
									]
								}
							}
						}
					}
				}
			}
		},
		"/api/ps": {
			"$ref": "#/paths/~1api~1tags"
		},
		"/mcp": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Call tools exposed by configured MCP servers",
				"description": "A minimal JSON-RPC MCP proxy supporting initialize, tools/list, and tools/call. Requests without an id are treated as notifications and return 202 without a response body.",
				"tags": [
					"mcp"
				],
				"requestBody": {
					"required": true,
					"content": {
						"application/json": {
							"schema": {
								"type": "object",
								"properties": {
									"jsonrpc": {
										"type": "string",
										"enum": [
											"2.0"
										]
									},
									"id": {
										"oneOf": [
											{
												"type": "integer"
											},
											{
												"type": "string"
											}
										],
										"nullable": true
									},
									"method": {
										"type": "string",
										"enum": [
											"initialize",
											"tools/list",
											"tools/call"
										]
									},
									"params": {
										"type": "object",
										"additionalProperties": true
									}
								},
								"required": [
									"jsonrpc",
									"method"
								]
							}
						}
					}
				},
				"responses": {
					"200": {
						"description": "JSON-RPC result or error returned by KoboldCpp or the selected MCP server.",
						"content": {
							"application/json": {
								"schema": {
									"type": "object",
									"properties": {
										"jsonrpc": {
											"type": "string",
											"enum": [
												"2.0"
											]
										},
										"id": {
											"oneOf": [
												{
													"type": "integer"
												},
												{
													"type": "string"
												}
											],
											"nullable": true
										},
										"result": {
											"type": "object",
											"additionalProperties": true
										},
										"error": {
											"type": "object",
											"properties": {
												"code": {
													"type": "integer"
												},
												"message": {
													"type": "string"
												}
											},
											"required": [
												"code",
												"message"
											]
										}
									}
								}
							}
						}
					},
					"202": {
						"description": "Notification accepted; no response body."
					},
					"400": {
						"description": "Invalid JSON-RPC input."
					},
					"401": {
						"$ref": "#/components/responses/Unauthorized"
					}
				}
			}
		},
		"/api/v1/config/max_context_length": {
			"get": {
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"value": 2048
								},
								"schema": {
									"$ref": "#/components/schemas/MaxContextLengthSetting"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Retrieve the current max context length setting value that public backends see",
				"tags": [
					"api/v1"
				]
			}
		},
		"/api/v1/config/max_length": {
			"get": {
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"value": 80
								},
								"schema": {
									"$ref": "#/components/schemas/MaxLengthSetting"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Retrieve the current max length (amount to generate) setting value",
				"tags": [
					"api/v1"
				]
			}
		},
		"/api/v1/generate": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Generates text given a prompt and generation settings.\n\nUnspecified values are set to defaults.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"max_context_length": 2048,
								"max_length": 100,
								"prompt": "Niko the kobold stalked carefully down the alley, his small scaly figure obscured by a dusky cloak that fluttered lightly in the cold winter breeze.",
								"quiet": false,
								"rep_pen": 1.1,
								"rep_pen_range": 256,
								"rep_pen_slope": 1,
								"temperature": 0.5,
								"tfs": 1.0,
								"top_a": 0,
								"top_k": 100,
								"top_p": 0.9,
								"typical": 1.0
							},
							"schema": {
								"$ref": "#/components/schemas/GenerationInput"
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"results": [
										{
											"text": " Holding up his tail to keep it from dragging in the dirty snow that covered the cobblestone, he waited patiently for the butcher to turn his attention from his stall so that he could pilfer his next meal: a tender-looking chicken."
										}
									]
								},
								"schema": {
									"$ref": "#/components/schemas/GenerationOutput"
								}
							}
						},
						"description": "Successful request"
					},
					"503": {
						"content": {
							"application/json": {
								"example": {
									"detail": {
										"msg": "Server is busy; please try again later.",
										"type": "service_unavailable"
									}
								},
								"schema": {
									"$ref": "#/components/schemas/ServerBusyError"
								}
							}
						},
						"description": "Server is busy"
					}
				},
				"summary": "Generate text with a specified prompt",
				"tags": [
					"api/v1"
				]
			}
		},
		"/api/v1/info/version": {
			"get": {
				"description": "Returns the matching *KoboldAI* (United) version of the API that you are currently using. This is not the same as the KoboldCpp API version - this is used to feature match against KoboldAI United.",
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"result": "1.2.5"
								},
								"schema": {
									"$ref": "#/components/schemas/BasicResult"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Current KoboldAI United API version",
				"tags": [
					"api/v1"
				]
			}
		},
		"/api/v1/model": {
			"get": {
				"security": [
					{
						"BearerAuth": []
					},
					{}
				],
				"description": "Gets the current model display name. When --password is configured, a missing or invalid Bearer token does not return HTTP 401; the endpoint returns `koboldcpp/protected-model` instead. A valid server or admin password reveals the real display name.",
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"result": "koboldcpp/airoboros-l2-7b-2.2"
								},
								"schema": {
									"$ref": "#/components/schemas/BasicResult"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Retrieve the current model string.",
				"tags": [
					"api/v1"
				]
			}
		},
		"/api/extra/true_max_context_length": {
			"get": {
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"value": 2048
								},
								"schema": {
									"$ref": "#/components/schemas/MaxContextLengthSetting"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Retrieve the actual max context length setting value set from the launcher",
				"description": "Retrieve the actual max context length setting value set from the launcher",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/version": {
			"get": {
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"result": "KoboldCpp",
									"version": "2026.11.01",
									"protected": false,
									"llm": true,
									"txt2img": false,
									"vision": false,
									"audio": false,
									"transcribe": false,
									"multiplayer": false,
									"websearch": false,
									"tts": false,
									"embeddings": false,
									"music": false,
									"musicllm": false,
									"musicfamily": "none"
								},
								"schema": {
									"$ref": "#/components/schemas/KcppVersion"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"description": "Retrieve the KoboldCpp backend version",
				"summary": "Retrieve the KoboldCpp backend version",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/preloadstory": {
			"get": {
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"prompt": "Hello world",
									"memory": "Some text",
									"authorsnote": "",
									"actions": []
								}
							}
						},
						"description": "Successful request"
					}
				},
				"description": "Retrieves the KoboldCpp preloaded story, --preloadstory configures a prepared story json save file to be hosted on the server, which frontends (such as KoboldAI Lite) can access over the API.",
				"summary": "Retrieves the KoboldCpp preloaded story",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/perf": {
			"get": {
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"last_process": 0.76,
									"last_eval": 65.8,
									"last_token_count": 26,
									"last_seed": 427343,
									"last_draft_success": 0,
									"last_draft_failed": 0,
									"total_gens": 1724,
									"stop_reason": 0,
									"total_img_gens": 0,
									"total_tts_gens": 0,
									"total_transcribe_gens": 0,
									"queue": 0,
									"idle": 0,
									"hordeexitcounter": -1,
									"uptime": 2255,
									"idletime": 3.5,
									"quiet": true
								},
								"schema": {
									"$ref": "#/components/schemas/KcppPerf"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"description": "Retrieve the KoboldCpp recent performance information",
				"summary": "Retrieve the KoboldCpp recent performance information",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/multiplayer/status": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"sender": "KCPP_1234",
								"senderbusy": true
							},
							"schema": {
								"properties": {
									"senderbusy": {
										"type": "boolean"
									},
									"sender": {
										"type": "string"
									}
								},
								"type": "object"
							}
						}
					},
					"required": false
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"turn_major": 1,
									"turn_minor": 1,
									"idle": true,
									"data_format": ""
								},
								"schema": {
									"properties": {
										"turn_major": {
											"type": "integer"
										},
										"turn_minor": {
											"type": "integer"
										},
										"idle": {
											"type": "boolean"
										},
										"data_format": {
											"type": "string"
										}
									},
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"description": "Fetches the current multiplayer turn information. Only useful for Multiplayer sessions in KoboldAI Lite.",
				"summary": "Fetches the current multiplayer turn information.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/multiplayer/getstory": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"responses": {
					"200": {
						"content": {
							"text/plain": {
								"schema": {
									"type": "string",
									"example": "base64_lzma_str"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"description": "Fetches the current multiplayer story data, LZMA compressed encoded base64. Data is usually in the same format is KAI Lite compressed savefiles.",
				"summary": "Fetches the current multiplayer story data, LZMA compressed encoded base64",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/multiplayer/setstory": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Sets the current multiplayer story and increments the turn.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"full_update": true,
								"sender": "LITE_UID_123456",
								"data_format": "kcpp_lzma_b64",
								"data": "base64_lzma_str"
							},
							"schema": {
								"properties": {
									"full_update": {
										"type": "boolean"
									},
									"sender": {
										"type": "string"
									},
									"data_format": {
										"type": "string"
									},
									"data": {
										"type": "string"
									}
								},
								"type": "object"
							}
						}
					},
					"required": false
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"success": true,
									"turn_major": 2,
									"turn_minor": 1,
									"idle": true,
									"data_format": "kcpp_lzma_b64"
								},
								"schema": {
									"properties": {
										"success": {
											"type": "boolean"
										},
										"turn_major": {
											"type": "integer"
										},
										"turn_minor": {
											"type": "integer"
										},
										"idle": {
											"type": "boolean"
										},
										"data_format": {
											"type": "string"
										}
									},
									"required": [
										"success",
										"turn_major",
										"turn_minor",
										"idle",
										"data_format"
									],
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Sets the current multiplayer story and increments the turn.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/generate/stream": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Generates text given a prompt and generation settings, with Server-Sent Events (SSE) streaming.\n\nUnspecified values are set to defaults.\n\nThe response uses `text/event-stream`. Each event has `event: message` and a JSON `data` object containing `token` (a generated text fragment) and `finish_reason`. Events are separated by a blank line. Concatenate the `token` values to obtain the generated text.\n\n`finish_reason` is `null` while generation is in progress. The final event has an empty `token` and a `finish_reason` of `stop`, `length`, or `error`. The server then closes the connection; no `[DONE]` sentinel is sent.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"prompt": "Niko the kobold stalked carefully down the alley, his small scaly figure obscured by a dusky cloak that fluttered lightly in the cold winter breeze.",
								"temperature": 0.5,
								"top_p": 0.9
							},
							"schema": {
								"$ref": "#/components/schemas/GenerationInput"
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"text/event-stream": {
								"example": "event: message\ndata: {\"token\": \" Holding\", \"finish_reason\": null}\n\nevent: message\ndata: {\"token\": \" up his tail\", \"finish_reason\": null}\n\nevent: message\ndata: {\"token\": \"\", \"finish_reason\": \"length\"}\n\n",
								"schema": {
									"type": "string"
								}
							}
						},
						"description": "Generated text streamed as SSE message events"
					},
					"503": {
						"content": {
							"application/json": {
								"example": {
									"detail": {
										"msg": "Server is busy; please try again later.",
										"type": "service_unavailable"
									}
								},
								"schema": {
									"$ref": "#/components/schemas/ServerBusyError"
								}
							}
						},
						"description": "Server is busy"
					}
				},
				"summary": "Generate text with a specified prompt. SSE streamed results.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/generate/check": {
			"get": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"results": [
										{
											"text": ", my name is Nik"
										}
									]
								},
								"schema": {
									"$ref": "#/components/schemas/GenerationOutput"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Poll the incomplete results of the currently ongoing text generation.",
				"description": "Poll the incomplete results of the currently ongoing text generation. Will not work when multiple requests are in queue.",
				"tags": [
					"api/extra"
				]
			},
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Poll the incomplete results of the currently ongoing text generation. A unique genkey previously submitted allows polling even in multiuser mode.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"genkey": "KCPP2342"
							},
							"schema": {
								"properties": {
									"genkey": {
										"type": "string",
										"description": "A unique key used to identify this generation while it is in progress."
									}
								},
								"type": "object"
							}
						}
					},
					"required": false
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"results": [
										{
											"text": ", my name is Nik"
										}
									]
								},
								"schema": {
									"$ref": "#/components/schemas/GenerationOutput"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Poll the incomplete results of the currently ongoing text generation. Supports multiuser mode.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/last_logprobs": {
			"get": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Obtains the token logprobs of the most recent request. In multiuser mode, use POST with a genkey instead.",
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"schema": {
									"type": "object",
									"properties": {
										"logprobs": {
											"type": "object",
											"nullable": true,
											"additionalProperties": true
										}
									}
								}
							}
						},
						"description": "The most recent logprobs, or null when none are available."
					}
				},
				"summary": "Obtains the most recent token logprobs.",
				"tags": [
					"api/extra"
				]
			},
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Obtains the token logprobs of the most recent request. A unique genkey previously submitted is required in multiuser mode.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"genkey": "KCPP2342"
							},
							"schema": {
								"properties": {
									"genkey": {
										"type": "string",
										"description": "A unique key used to identify the previous generation."
									}
								},
								"type": "object"
							}
						}
					},
					"required": false
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"logprobs": {
										"content": [
											{
												"token": "Hello",
												"logprob": -0.31725305,
												"bytes": [
													72,
													101,
													108,
													108,
													111
												],
												"top_logprobs": [
													{
														"token": "Hello",
														"logprob": -0.31725305,
														"bytes": [
															72,
															101,
															108,
															108,
															111
														]
													},
													{
														"token": "Hi",
														"logprob": -1.3190403,
														"bytes": [
															72,
															105
														]
													}
												]
											},
											{
												"token": "!",
												"logprob": -0.02380986,
												"bytes": [
													33
												],
												"top_logprobs": [
													{
														"token": "!",
														"logprob": -0.02380986,
														"bytes": [
															33
														]
													},
													{
														"token": " there",
														"logprob": -3.787621,
														"bytes": [
															32,
															116,
															104,
															101,
															114,
															101
														]
													}
												]
											},
											{
												"token": " How",
												"logprob": -0.000054669687,
												"bytes": [
													32,
													72,
													111,
													119
												],
												"top_logprobs": [
													{
														"token": " How",
														"logprob": -0.000054669687,
														"bytes": [
															32,
															72,
															111,
															119
														]
													},
													{
														"token": "<|end|>",
														"logprob": -10.953937,
														"bytes": null
													}
												]
											},
											{
												"token": " can",
												"logprob": -0.015801601,
												"bytes": [
													32,
													99,
													97,
													110
												],
												"top_logprobs": [
													{
														"token": " can",
														"logprob": -0.015801601,
														"bytes": [
															32,
															99,
															97,
															110
														]
													},
													{
														"token": " may",
														"logprob": -4.161023,
														"bytes": [
															32,
															109,
															97,
															121
														]
													}
												]
											},
											{
												"token": " I",
												"logprob": -0.0000037697225,
												"bytes": [
													32,
													73
												],
												"top_logprobs": [
													{
														"token": " I",
														"logprob": -0.0000037697225,
														"bytes": [
															32,
															73
														]
													},
													{
														"token": " assist",
														"logprob": -13.596657,
														"bytes": [
															32,
															97,
															115,
															115,
															105,
															115,
															116
														]
													}
												]
											},
											{
												"token": " assist",
												"logprob": -0.04571125,
												"bytes": [
													32,
													97,
													115,
													115,
													105,
													115,
													116
												],
												"top_logprobs": [
													{
														"token": " assist",
														"logprob": -0.04571125,
														"bytes": [
															32,
															97,
															115,
															115,
															105,
															115,
															116
														]
													},
													{
														"token": " help",
														"logprob": -3.1089056,
														"bytes": [
															32,
															104,
															101,
															108,
															112
														]
													}
												]
											},
											{
												"token": " you",
												"logprob": -0.0000054385737,
												"bytes": [
													32,
													121,
													111,
													117
												],
												"top_logprobs": [
													{
														"token": " you",
														"logprob": -0.0000054385737,
														"bytes": [
															32,
															121,
															111,
															117
														]
													},
													{
														"token": " today",
														"logprob": -12.807695,
														"bytes": [
															32,
															116,
															111,
															100,
															97,
															121
														]
													}
												]
											},
											{
												"token": " today",
												"logprob": -0.0040071653,
												"bytes": [
													32,
													116,
													111,
													100,
													97,
													121
												],
												"top_logprobs": [
													{
														"token": " today",
														"logprob": -0.0040071653,
														"bytes": [
															32,
															116,
															111,
															100,
															97,
															121
														]
													},
													{
														"token": "?",
														"logprob": -5.5247097,
														"bytes": [
															63
														]
													}
												]
											},
											{
												"token": "?",
												"logprob": -0.0008108172,
												"bytes": [
													63
												],
												"top_logprobs": [
													{
														"token": "?",
														"logprob": -0.0008108172,
														"bytes": [
															63
														]
													},
													{
														"token": "?\n",
														"logprob": -7.184561,
														"bytes": [
															63,
															10
														]
													}
												]
											}
										]
									}
								},
								"schema": {
									"properties": {
										"logprobs": {
											"type": "object",
											"nullable": true,
											"additionalProperties": true,
											"description": "A logprobs object in the same format as OpenAI API."
										}
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Obtains the token logprobs of the most recent request.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/tokencount": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Counts the number of tokens in a string, and returns their token IDs. Also aliased to /api/extra/tokenize",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"prompt": "Hello, my name is Niko."
							},
							"schema": {
								"properties": {
									"prompt": {
										"type": "string",
										"description": "The string to be tokenized."
									}
								},
								"type": "object"
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"value": 9,
									"ids": [
										1,
										22557,
										28725,
										586,
										1141,
										349,
										11952,
										28709,
										28723
									]
								},
								"schema": {
									"properties": {
										"value": {
											"type": "number"
										},
										"ids": {
											"type": "array",
											"items": {
												"type": "integer"
											}
										}
									},
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Counts the number of tokens in a string.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/tokenize": {
			"$ref": "#/paths/~1api~1extra~1tokencount"
		},
		"/api/extra/detokenize": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Converts an array of token IDs into a string.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"ids": [
									529,
									29989,
									5205,
									29989,
									29958,
									13
								]
							},
							"schema": {
								"properties": {
									"ids": {
										"type": "array",
										"items": {
											"type": "number"
										}
									}
								},
								"type": "object"
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"result": "<|system|>\n",
									"success": true
								},
								"schema": {
									"properties": {
										"result": {
											"type": "string",
											"description": "The detokenized string."
										},
										"success": {
											"type": "boolean"
										}
									},
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Converts an array of token IDs into a string.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/abort": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Aborts the currently ongoing text generation. Does not work when multiple requests are in queue.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"genkey": "KCPP2342"
							},
							"schema": {
								"properties": {
									"genkey": {
										"type": "string",
										"description": "A unique key used to identify this generation while it is in progress."
									}
								},
								"type": "object"
							}
						}
					},
					"required": false
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"success": "true",
									"done": "true"
								},
								"schema": {
									"properties": {
										"success": {
											"type": "string",
											"enum": [
												"true",
												"false"
											],
											"description": "Whether the abort was successful. Returned as a JSON string for compatibility."
										},
										"done": {
											"type": "string",
											"enum": [
												"true",
												"false"
											],
											"description": "Whether the target generation was aborted immediately. Returned as a JSON string for compatibility."
										}
									},
									"required": [
										"success",
										"done"
									],
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Aborts the currently ongoing text generation.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/transcribe": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Uses the loaded audio transcription model to perform Speech-To-Text transcription. This can use Whisper, or an audio-capable multimodal projector when Whisper is unavailable.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"prompt": "",
								"suppress_non_speech": false,
								"langcode": "en",
								"audio_data": "base64_wav_data"
							},
							"schema": {
								"properties": {
									"audio_data": {
										"type": "string",
										"description": "Base64 representation of an audio file to transcribe. A data:audio URL is also accepted."
									},
									"prompt": {
										"type": "string",
										"description": "Prompt to steer the transcription."
									},
									"langcode": {
										"type": "string",
										"description": "Two letter language code, or use auto to autodetect."
									},
									"language": {
										"type": "string",
										"description": "Alias for langcode."
									},
									"suppress_non_speech": {
										"type": "boolean",
										"description": "Prevent noise tokens, always generate words for speech."
									}
								},
								"required": [
									"audio_data"
								],
								"type": "object"
							}
						},
						"multipart/form-data": {
							"schema": {
								"type": "object",
								"properties": {
									"file": {
										"type": "string",
										"format": "binary"
									},
									"prompt": {
										"type": "string"
									},
									"language": {
										"type": "string",
										"description": "Language code, or auto when omitted."
									}
								},
								"required": [
									"file"
								]
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"text": "Hello world"
								},
								"schema": {
									"$ref": "#/components/schemas/TranscriptionResult"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Uses Whisper to perform a Speech-To-Text transcription.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/music/transcribe": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Transcribes music or audio to text and ABC notation",
				"description": "Uses a SheetSage2 audio transcription model to convert music into ABC notation. The response contains the transcription in both `text` and `abc`; JSON base64/data URLs and multipart file uploads are accepted.",
				"requestBody": {
					"required": true,
					"content": {
						"application/json": {
							"example": {
								"audio_data": "base64_audio_data",
								"langcode": "en"
							},
							"schema": {
								"type": "object",
								"properties": {
									"audio_data": {
										"type": "string",
										"description": "Base64 audio data or a data:audio URL."
									},
									"prompt": {
										"type": "string",
										"description": "Optional transcription prompt."
									},
									"langcode": {
										"type": "string",
										"description": "Language code, or auto."
									},
									"language": {
										"type": "string",
										"description": "Alias for langcode."
									},
									"suppress_non_speech": {
										"type": "boolean"
									}
								},
								"required": [
									"audio_data"
								]
							}
						},
						"multipart/form-data": {
							"schema": {
								"type": "object",
								"properties": {
									"file": {
										"type": "string",
										"format": "binary"
									},
									"prompt": {
										"type": "string"
									},
									"language": {
										"type": "string"
									}
								},
								"required": [
									"file"
								]
							}
						}
					}
				},
				"responses": {
					"200": {
						"description": "Transcription and ABC notation.",
						"content": {
							"application/json": {
								"schema": {
									"$ref": "#/components/schemas/TranscriptionResult"
								}
							}
						}
					}
				},
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/websearch": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Searches the web using DuckDuckGo and returns the top 3 results.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"q": "What is KoboldCpp"
							},
							"schema": {
								"properties": {
									"q": {
										"type": "string",
										"description": "The search query string"
									}
								},
								"type": "object"
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": [
									{
										"title": "KoboldCpp Wiki",
										"url": "https://github.com/LostRuins/koboldcpp/wiki",
										"desc": "KoboldCpp is a program to run LLMs",
										"content": "KoboldCpp is a program to run LLMs using GGUF files"
									}
								],
								"schema": {
									"type": "array",
									"items": {
										"type": "object",
										"properties": {
											"title": {
												"type": "string"
											},
											"url": {
												"type": "string"
											},
											"desc": {
												"type": "string"
											},
											"content": {
												"type": "string"
											}
										},
										"required": [
											"title",
											"url",
											"desc",
											"content"
										]
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Searches the web using DuckDuckGo and returns the top 3 results.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/tts": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Creates text-to-speech audio from input text.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"input": "hello world, how are you today?",
								"voice": "kobo",
								"language": "en",
								"response_format": "wav"
							},
							"schema": {
								"properties": {
									"input": {
										"type": "string",
										"description": "The text to generate audio for. Try to keep it short."
									},
									"voice": {
										"type": "string",
										"description": "Voice name. Built-in names, OpenAI names such as alloy, or a WAV/MP3 filename loaded with --ttsdir can be used. Unknown names are converted to a deterministic speaker seed when supported by the model. There are a few preset voices you can use: kobo,cheery,sleepy,shouty,chatty"
									},
									"speaker_wav": {
										"type": "string",
										"description": "Alias for voice, accepted for compatible TTS clients."
									},
									"speaker_json": {
										"type": "string",
										"description": "Custom speaker JSON. More info at https://github.com/LostRuins/koboldcpp/tree/concedo/examples/outetts"
									},
									"instructions": {
										"type": "string",
										"description": "Some TTS models only. Provide an instruction on how the narration should sound e.g. Angry man shouting with posh british accent"
									},
									"language": {
										"type": "string",
										"default": "en",
										"description": "Language code passed to the TTS backend."
									},
									"response_format": {
										"type": "string",
										"enum": [
											"wav",
											"mp3"
										],
										"default": "wav"
									},
									"use_mp3": {
										"type": "boolean",
										"description": "KoboldCpp alias for requesting MP3 output."
									},
									"seed": {
										"type": "integer",
										"default": -1,
										"description": "Audio generation seed."
									},
									"reference_text": {
										"type": "string",
										"description": "Transcript of the reference voice clip when required by the loaded model."
									}
								},
								"required": [
									"input"
								],
								"type": "object",
								"additionalProperties": true
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"audio/wav": {
								"schema": {
									"type": "string",
									"format": "binary"
								}
							},
							"audio/mpeg": {
								"schema": {
									"type": "string",
									"format": "binary"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Creates text-to-speech audio from input text.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/speakers_list": {
			"get": {
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": [
									"kobo",
									"cheery",
									"sleepy",
									"shouty",
									"chatty"
								],
								"schema": {
									"type": "array",
									"items": {
										"type": "string"
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Get a list of available TTS speakers.",
				"description": "Get a list of available TTS speakers.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/api/extra/embeddings": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Creates an embedding vector representing the input text. Please refer to OpenAI documentation",
				"description": "Creates an embedding vector representing the input text.\n\nThis is an OpenAI compatibility endpoint.\n\n Please refer to OpenAI documentation at [https://developers.openai.com/docs/api-reference/embeddings/create](https://developers.openai.com/docs/api-reference/embeddings/create)",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"model": "kcpp",
								"input": "Niko the Kobold is in town today.",
								"truncate": true
							},
							"schema": {
								"properties": {
									"model": {
										"type": "string",
										"description": "Not used, depends on loaded kcpp embeddings model."
									},
									"input": {
										"type": "string",
										"description": "String to convert into embedding vector"
									},
									"truncate": {
										"type": "boolean",
										"description": "If the string is too long, truncate it. Otherwise, exceeding max embedding size will cause the request to fail."
									}
								},
								"type": "object"
							}
						}
					},
					"required": true
				},
				"tags": [
					"api/extra"
				],
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"object": "list",
									"data": [
										{
											"object": "embedding",
											"index": 0,
											"embedding": [
												0.089203,
												0.016367,
												0.062196,
												-0.045898,
												-0.019921
											]
										}
									],
									"model": "embedmodel",
									"usage": {
										"prompt_tokens": 100,
										"total_tokens": 100
									}
								},
								"schema": {
									"properties": {},
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				}
			}
		},
		"/api/extra/music/prepare": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Creates song generation parameters such as caption, lyrics, BPM and duration",
				"description": "Creates song generation parameters such as caption, lyrics, BPM and duration. This should be called to produce the generation input for /api/extra/music/generate",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"caption": "An emotional rap song about the kobold war."
							},
							"schema": {
								"properties": {
									"caption": {
										"type": "string",
										"description": "A short description of the song to create"
									},
									"lyrics": {
										"type": "string",
										"description": "Lyrics to preserve or use for planning."
									},
									"bpm": {
										"type": "number",
										"description": "ACE-Step beats per minute."
									},
									"duration": {
										"type": "number",
										"description": "ACE-Step duration in seconds."
									},
									"keyscale": {
										"type": "string",
										"description": "ACE-Step musical key."
									},
									"timesignature": {
										"type": "string",
										"description": "ACE-Step time signature."
									},
									"vocal_language": {
										"type": "string",
										"description": "Language code for the lyrics."
									},
									"seed": {
										"type": "integer",
										"description": "Music generation seed."
									},
									"musicfamily": {
										"type": "string",
										"enum": [
											"acestep",
											"yue2"
										],
										"description": "Select the loaded music family."
									},
									"gen_codes": {
										"type": "boolean",
										"description": "Generate a planner/code response."
									},
									"rewrite_caption": {
										"type": "boolean",
										"default": true
									},
									"stereo": {
										"type": "boolean",
										"default": true
									},
									"use_mp3": {
										"type": "boolean",
										"description": "Request MP3 output."
									},
									"response_format": {
										"type": "string",
										"enum": [
											"wav",
											"mp3"
										]
									},
									"audio_codes": {
										"type": "string",
										"description": "ACE-Step audio-code plan from a previous response."
									},
									"music_reference_audio_data": {
										"type": "string",
										"description": "Base64 audio or a data:audio URL for ACE-Step reference/cover generation. Not used by YuE2."
									},
									"audio_cover_strength": {
										"type": "number",
										"description": "ACE-Step reference audio strength, normally 0.0 to 1.0."
									},
									"lm_temperature": {
										"type": "number"
									},
									"lm_cfg_scale": {
										"type": "number"
									},
									"lm_top_p": {
										"type": "number"
									},
									"lm_top_k": {
										"type": "integer"
									},
									"lm_rep_pen": {
										"type": "number"
									},
									"inference_steps": {
										"type": "integer",
										"description": "ACE-Step diffusion steps or YuE2 acoustic steps."
									},
									"guidance_scale": {
										"type": "number"
									},
									"shift": {
										"type": "number",
										"description": "ACE-Step audio shift."
									},
									"codes_top_p": {
										"type": "number"
									},
									"codes_top_k": {
										"type": "integer"
									},
									"codes_temperature": {
										"type": "number"
									},
									"abc": {
										"type": "string",
										"description": "YuE2 ABC score."
									},
									"cot": {
										"type": "string",
										"enum": [
											"full",
											"melody",
											"off"
										],
										"description": "YuE2 score planning mode."
									},
									"semantic_prefix": {
										"type": "array",
										"items": {
											"type": "integer"
										},
										"description": "YuE2 semantic token prefix from a previous plan."
									},
									"num_inference_steps": {
										"type": "integer",
										"description": "YuE2 acoustic inference steps."
									},
									"semantic_top_p": {
										"type": "number"
									},
									"semantic_top_k": {
										"type": "integer"
									},
									"semantic_temperature": {
										"type": "number"
									},
									"abc_temperature": {
										"type": "number"
									},
									"abc_top_p": {
										"type": "number"
									},
									"abc_top_k": {
										"type": "integer"
									},
									"semantic_repetition_penalty": {
										"type": "number"
									},
									"semantic_min_tokens": {
										"type": "integer"
									},
									"semantic_max_tokens": {
										"type": "integer"
									}
								},
								"type": "object",
								"additionalProperties": true
							}
						}
					},
					"required": true
				},
				"tags": [
					"api/extra"
				],
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"caption": "A melancholic and narrative-driven rap track built around a heavy beat",
									"lyrics": "\n[Verse 1]\nKobold is love, yeah, kobold is life\nKobold is the only way we survive\nShe said okay, yo, keep it that way\nIn kobold we trust, just kobold today\n\n[Chorus]\nKobold, kobold, we carry on now\nKobold, kobold, each way and how\nKobold, kobold, right here we go\nKobold, kobold, all that I know.\n\n[Outro]",
									"bpm": 120,
									"duration": 64.0,
									"keyscale": "G minor",
									"timesignature": "2",
									"vocal_language": "en",
									"task_type": "text2music",
									"seed": 622315,
									"lm_temperature": 0.85,
									"lm_cfg_scale": 3.0,
									"lm_top_p": 0.9,
									"lm_top_k": 50,
									"lm_rep_pen": 1.03,
									"inference_steps": 8,
									"guidance_scale": 1.0,
									"shift": 3.0,
									"rewrite_caption": true,
									"audio_codes": ""
								},
								"schema": {
									"type": "object",
									"description": "A music plan. ACE-Step plans commonly include audio_codes; YuE2 plans include abc and semantic_prefix.",
									"properties": {
										"caption": {
											"type": "string"
										},
										"lyrics": {
											"type": "string"
										},
										"bpm": {
											"type": "number"
										},
										"duration": {
											"type": "number"
										},
										"keyscale": {
											"type": "string"
										},
										"timesignature": {
											"type": "string"
										},
										"vocal_language": {
											"type": "string"
										},
										"task_type": {
											"type": "string"
										},
										"seed": {
											"type": "integer"
										},
										"audio_codes": {
											"type": "string"
										},
										"abc": {
											"type": "string"
										},
										"semantic_prefix": {
											"type": "array",
											"items": {
												"type": "integer"
											}
										},
										"musicfamily": {
											"type": "string"
										},
										"rewrite_caption": {
											"type": "boolean"
										}
									},
									"additionalProperties": true
								}
							}
						},
						"description": "Successful request"
					}
				}
			}
		},
		"/api/extra/music/generate": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Generates music based on provided captions, lyrics and configurations",
				"description": "Generates music based on provided captions, lyrics and configurations. The config can be generated using /api/extra/music/prepare or crafted manually",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"caption": "A melancholic and narrative-driven rap track built around a heavy beat",
								"lyrics": "\n[Verse 1]\nKobold is love, yeah, kobold is life\nKobold is the only way we survive\nShe said okay, yo, keep it that way\nIn kobold we trust, just kobold today\n\n[Chorus]\nKobold, kobold, we carry on now\nKobold, kobold, each way and how\nKobold, kobold, right here we go\nKobold, kobold, all that I know.\n\n[Outro]",
								"bpm": 120,
								"duration": 64.0,
								"keyscale": "G minor",
								"timesignature": "2",
								"vocal_language": "en",
								"inference_steps": 8
							},
							"schema": {
								"properties": {
									"caption": {
										"type": "string",
										"description": "A short description of the song to create"
									},
									"lyrics": {
										"type": "string",
										"description": "The full lyrics of the song to generate"
									},
									"bpm": {
										"type": "number",
										"description": "The song Beats Per Minute"
									},
									"duration": {
										"type": "number",
										"description": "The length of the song, in seconds."
									},
									"keyscale": {
										"type": "string",
										"description": "The musical key of the song."
									},
									"timesignature": {
										"type": "string",
										"description": "The musical time signature of the song."
									},
									"vocal_language": {
										"type": "string",
										"description": "The language of the song lyrics."
									},
									"inference_steps": {
										"type": "number",
										"description": "How many diffusion steps to use."
									},
									"musicfamily": {
										"type": "string",
										"enum": [
											"acestep",
											"yue2"
										]
									},
									"seed": {
										"type": "integer"
									},
									"gen_codes": {
										"type": "boolean"
									},
									"rewrite_caption": {
										"type": "boolean",
										"default": true
									},
									"stereo": {
										"type": "boolean",
										"default": true
									},
									"use_mp3": {
										"type": "boolean"
									},
									"response_format": {
										"type": "string",
										"enum": [
											"wav",
											"mp3"
										]
									},
									"audio_codes": {
										"type": "string",
										"description": "ACE-Step audio-code plan."
									},
									"music_reference_audio_data": {
										"type": "string",
										"description": "Base64 audio or data:audio URL for ACE-Step reference/cover generation."
									},
									"audio_cover_strength": {
										"type": "number"
									},
									"lm_temperature": {
										"type": "number"
									},
									"lm_cfg_scale": {
										"type": "number"
									},
									"lm_top_p": {
										"type": "number"
									},
									"lm_top_k": {
										"type": "integer"
									},
									"lm_rep_pen": {
										"type": "number"
									},
									"guidance_scale": {
										"type": "number"
									},
									"shift": {
										"type": "number"
									},
									"codes_top_p": {
										"type": "number"
									},
									"codes_top_k": {
										"type": "integer"
									},
									"codes_temperature": {
										"type": "number"
									},
									"abc": {
										"type": "string",
										"description": "YuE2 ABC score."
									},
									"cot": {
										"type": "string",
										"enum": [
											"full",
											"melody",
											"off"
										]
									},
									"semantic_prefix": {
										"type": "array",
										"items": {
											"type": "integer"
										}
									},
									"num_inference_steps": {
										"type": "integer"
									},
									"semantic_top_p": {
										"type": "number"
									},
									"semantic_top_k": {
										"type": "integer"
									},
									"semantic_temperature": {
										"type": "number"
									},
									"abc_temperature": {
										"type": "number"
									},
									"abc_top_p": {
										"type": "number"
									},
									"abc_top_k": {
										"type": "integer"
									},
									"semantic_repetition_penalty": {
										"type": "number"
									},
									"semantic_min_tokens": {
										"type": "integer"
									},
									"semantic_max_tokens": {
										"type": "integer"
									}
								},
								"type": "object",
								"additionalProperties": true
							}
						}
					},
					"required": true
				},
				"tags": [
					"api/extra"
				],
				"responses": {
					"200": {
						"content": {
							"audio/wav": {
								"schema": {
									"type": "string",
									"format": "binary"
								}
							},
							"audio/mpeg": {
								"schema": {
									"type": "string",
									"format": "binary"
								}
							}
						},
						"description": "Successful request"
					}
				}
			}
		},
		"/api/extra/json_to_grammar": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"summary": "Converts a provided JSON schema into GBNF grammar.",
				"description": "Converts a provided JSON schema into GBNF grammar. Example schema at [https://developers.openai.com/docs/guides/structured-outputs](https://developers.openai.com/docs/guides/structured-outputs)",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"schema": {
									"type": "object",
									"properties": {
										"action_items": {
											"type": "array",
											"items": {
												"type": "object",
												"properties": {
													"description": {
														"type": "string",
														"description": "Description of the action item."
													},
													"due_date": {
														"type": [
															"string",
															"null"
														],
														"description": "Due date for the action item, can be null if not specified."
													},
													"owner": {
														"type": [
															"string",
															"null"
														],
														"description": "Owner responsible for the action item, can be null if not specified."
													}
												},
												"required": [
													"description",
													"due_date",
													"owner"
												],
												"additionalProperties": false
											},
											"description": "List of action items from the meeting."
										}
									},
									"required": [
										"action_items"
									],
									"additionalProperties": false
								}
							},
							"schema": {
								"properties": {
									"schema": {
										"type": "object",
										"description": "JSON schema representing the desired output format."
									}
								},
								"type": "object"
							}
						}
					},
					"required": true
				},
				"tags": [
					"api/extra"
				],
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"result": "action-items ::= \"[\" space (action-items-item (\",\" space action-items-item)*)? \"]\" space\naction-items-item ::= \"{\" space action-items-item-description-kv \",\" space action-items-item-due-date-kv \",\" space action-items-item-owner-kv \"}\" space\naction-items-item-description-kv ::= \"\\\"description\\\"\" space \":\" space string\naction-items-item-due-date ::= string | null\naction-items-item-due-date-kv ::= \"\\\"due_date\\\"\" space \":\" space action-items-item-due-date\naction-items-item-owner ::= string | null\naction-items-item-owner-kv ::= \"\\\"owner\\\"\" space \":\" space action-items-item-owner\naction-items-kv ::= \"\\\"action_items\\\"\" space \":\" space action-items\nchar ::= [^\"\\\\\\x7F\\x00-\\x1F] | [\\\\] ([\"\\\\bfnrt] | \"u\" [0-9a-fA-F]{4})\nnull ::= \"null\" space\nroot ::= \"{\" space action-items-kv \"}\" space\nspace ::= | \" \" | \"\\n\"{1,2} [ \\t]{0,20}\nstring ::= \"\\\"\" char* \"\\\"\" space",
									"success": true
								},
								"schema": {
									"properties": {},
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				}
			}
		},
		"/api/extra/data/save": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Saves data to a slot in a database file in the KoboldCpp server.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"slot": "1",
								"format": "kcpp_lzma_b64",
								"title": "Untitled Story",
								"data": "base64_data"
							},
							"schema": {
								"properties": {
									"slot": {
										"type": "string",
										"description": "Save slot id to save to."
									},
									"format": {
										"type": "string",
										"description": "Save format, not used currently"
									},
									"title": {
										"type": "string",
										"description": "Title of this saved file"
									},
									"data": {
										"type": "string",
										"description": "Save data text string"
									}
								},
								"type": "object"
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"success": true,
									"error": ""
								},
								"schema": {
									"properties": {
										"success": {
											"type": "boolean",
											"description": "Whether the operation was successful."
										},
										"error": {
											"type": "string",
											"description": "What went wrong."
										}
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Saves data to a slot in a database file in the KoboldCpp server.",
				"tags": [
					"api/extra/data"
				]
			}
		},
		"/api/extra/data/load": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "Loads data from a save slot in the database file in the KoboldCpp server.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"slot": "1"
							},
							"schema": {
								"properties": {
									"slot": {
										"type": "string",
										"description": "Save slot id"
									}
								},
								"type": "object"
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"success": true,
									"data": {
										"title": "Untitled Story",
										"format": "kcpp_lzma_b64",
										"data": "base64_data"
									}
								},
								"schema": {
									"properties": {
										"success": {
											"type": "boolean",
											"description": "Whether the operation was successful."
										},
										"data": {
											"type": "object",
											"nullable": true,
											"description": "The saved slot entry, or null if the slot does not exist.",
											"properties": {
												"title": {
													"type": "string"
												},
												"format": {
													"type": "string"
												},
												"data": {
													"type": "string"
												}
											},
											"required": [
												"title",
												"format",
												"data"
											]
										}
									},
									"required": [
										"success",
										"data"
									],
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Loads data from a save slot in the database file in the KoboldCpp server.",
				"tags": [
					"api/extra/data"
				]
			}
		},
		"/api/extra/data/list": {
			"post": {
				"security": [
					{
						"BearerAuth": []
					}
				],
				"description": "List available saved slots from the KoboldCpp server, returns an array of strings containing their titles.",
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": [
									"Saved Story 1",
									"Saved Story 2",
									"",
									""
								],
								"schema": {
									"type": "array",
									"items": {
										"type": "string"
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "List available saved slots from the KoboldCpp server.",
				"tags": [
					"api/extra/data"
				]
			}
		},
		"/api/admin/list_options": {
			"get": {
				"security": [
					{
						"AdminBearerAuth": []
					}
				],
				"summary": "List available .kcpps files to load.",
				"description": "List available .kcpps files to load.",
				"tags": [
					"api/admin"
				],
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": [
									"file1.kcpps",
									"file2.kcpps"
								],
								"schema": {
									"type": "array",
									"items": {
										"type": "string"
									}
								}
							}
						},
						"description": "Successful request"
					}
				}
			}
		},
		"/api/admin/reload_config": {
			"post": {
				"security": [
					{
						"AdminBearerAuth": []
					}
				],
				"description": "Switches the loaded config, along with any settings and model file changes.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"filename": "file1.kcpps",
								"baseconfig": ""
							},
							"schema": {
								"properties": {
									"filename": {
										"type": "string",
										"description": "Filename of the .kcpps config to be loaded. Any associated files and models will be automatically swapped in."
									},
									"baseconfig": {
										"type": "string",
										"description": "If filename is a gguf, this allows other kcpps settings to be overlaid on top of that gguf."
									}
								},
								"type": "object"
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"success": true
								},
								"schema": {
									"properties": {
										"success": {
											"type": "boolean",
											"description": "Whether the operation was successful."
										}
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Switches the currently loaded .kcpps config, and reloads any changed files or models.",
				"tags": [
					"api/admin"
				]
			}
		},
		"/api/admin/check_state": {
			"post": {
				"security": [
					{
						"AdminBearerAuth": []
					}
				],
				"description": "Gets the number of bytes taken for existing save state, and predicts the bytes required for a new save state.",
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"success": true,
									"old_states": [
										{
											"tokens": 0,
											"size": 0
										},
										{
											"tokens": 0,
											"size": 0
										},
										{
											"tokens": 0,
											"size": 0
										}
									],
									"new_state_size": 0,
									"new_tokens": 0
								},
								"schema": {
									"properties": {
										"success": {
											"type": "boolean",
											"description": "Whether the operation was successful."
										},
										"old_states": {
											"type": "array",
											"items": {
												"type": "object",
												"properties": {
													"tokens": {
														"type": "number",
														"description": "Tokens in this saved state."
													},
													"size": {
														"type": "number",
														"description": "Size of this saved state in bytes."
													}
												}
											}
										},
										"new_state_size": {
											"type": "number",
											"description": "Bytes a new save state is estimated to consume."
										},
										"new_tokens": {
											"type": "number",
											"description": "How many tokens will be stored if a new save state is made."
										}
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Gets the number of bytes taken for existing save state, and predicts the bytes required for a new save state.",
				"tags": [
					"api/admin"
				]
			}
		},
		"/api/admin/save_state": {
			"post": {
				"security": [
					{
						"AdminBearerAuth": []
					}
				],
				"description": "Creates a new KV cache save state in memory. Overwrites any existing saved state.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"slot": 0
							},
							"schema": {
								"properties": {
									"slot": {
										"type": "number",
										"description": "Which slot index to save/load the state to/from."
									}
								},
								"type": "object"
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"success": true,
									"new_state_size": 12345678,
									"new_tokens": 100
								},
								"schema": {
									"properties": {
										"success": {
											"type": "boolean",
											"description": "Whether the operation was successful."
										},
										"new_state_size": {
											"type": "number",
											"description": "Bytes a new save state is estimated to consume."
										},
										"new_tokens": {
											"type": "number",
											"description": "How many context tokens were saved in state."
										}
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Creates a new KV cache save state in memory. Overwrites any existing saved state.",
				"tags": [
					"api/admin"
				]
			}
		},
		"/api/admin/load_state": {
			"post": {
				"security": [
					{
						"AdminBearerAuth": []
					}
				],
				"description": "Reloads a previous KV cache save state into context.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"slot": 0
							},
							"schema": {
								"properties": {
									"slot": {
										"type": "number",
										"description": "Which slot index to save/load the state to/from."
									}
								},
								"type": "object"
							}
						}
					},
					"required": true
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"success": true,
									"new_tokens": 100
								},
								"schema": {
									"properties": {
										"success": {
											"type": "boolean",
											"description": "Whether the operation was successful."
										},
										"new_tokens": {
											"type": "number",
											"description": "How many context tokens were loaded from state."
										}
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Reloads a previous KV cache save state into context.",
				"tags": [
					"api/admin"
				]
			}
		},
		"/api/admin/clear_state": {
			"post": {
				"security": [
					{
						"AdminBearerAuth": []
					}
				],
				"description": "Frees all previous KV cache save state.",
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"success": true
								},
								"schema": {
									"properties": {
										"success": {
											"type": "boolean",
											"description": "Whether the operation was successful."
										}
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Frees all previous KV cache save state.",
				"tags": [
					"api/admin"
				]
			}
		},
		"/api/extra/shutdown": {
			"post": {
				"description": "Shuts down the server and exits koboldcpp. Only usable from localhost! Both old and new KoboldCpp Server must have been launched with the --singleinstance flag for this to work.",
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"success": true
								},
								"schema": {
									"properties": {
										"success": {
											"type": "boolean",
											"description": "Whether the operation was successful."
										}
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Shuts down the current KoboldCpp server.",
				"tags": [
					"api/extra"
				]
			}
		},
		"/props": {
			"get": {
				"summary": "Returns the Jinja template stored in the GGUF model, if found.",
				"description": "Returns the Jinja template stored in the GGUF model, if found.",
				"tags": [
					"serviceinfo"
				],
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"chat_template": "string",
									"total_slots": 1,
									"default_generation_settings": {
										"n_ctx": 2048
									}
								},
								"schema": {
									"properties": {},
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				}
			}
		},
		"/.well-known/serviceinfo": {
			"get": {
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"version": "0.2",
									"software": {
										"name": "KoboldCpp",
										"version": 1.77,
										"repository": "https://github.com/LostRuins/koboldcpp",
										"homepage": "https://github.com/LostRuins/koboldcpp",
										"logo": "https://raw.githubusercontent.com/LostRuins/koboldcpp/refs/heads/concedo/niko.ico"
									},
									"api": {
										"koboldai": {
											"name": "KoboldAI API",
											"rel_url": "/api",
											"documentation": "https://lite.koboldai.net/koboldcpp_api",
											"version": 1.77
										},
										"openai": {
											"name": "OpenAI API",
											"rel_url ": "/v1",
											"documentation": "https://openai.com/documentation/api",
											"version": 1.77
										}
									}
								},
								"schema": {
									"properties": {},
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"description": "Retrieve the common API identity provider",
				"summary": "Retrieve the common API identity provider",
				"tags": [
					"serviceinfo"
				]
			}
		},
		"/sdapi/v1/sd-models": {
			"get": {
				"description": "Gets a list of image generation models. For koboldcpp, only one model will be returned. If no model is loaded, the list is empty.",
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": [
									{
										"title": "stable_diffusion",
										"model_name": "stable_diffusion",
										"hash": "8888888888",
										"sha256": "8888888888888888888888888888888888888888888888888888888888888888",
										"filename": "path_to_safetensors_model_file",
										"config": null
									}
								]
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Gets a list of image generation models",
				"tags": [
					"sdapi/v1"
				]
			}
		},
		"/sdapi/v1/options": {
			"get": {
				"description": "Gets configuration info for image generation, used to get loaded model name in A1111.",
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"samples_format": "png",
									"sd_model_checkpoint": "stable_diffusion"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Gets configuration info for image generation",
				"tags": [
					"sdapi/v1"
				]
			}
		},
		"/sdapi/v1/samplers": {
			"get": {
				"description": "Gets a list of supported samplers.",
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": [
									{
										"name": "Euler a",
										"aliases": [
											"k_euler_a",
											"k_euler_ancestral"
										],
										"options": {}
									},
									{
										"name": "Euler",
										"aliases": [
											"k_euler"
										],
										"options": {}
									},
									{
										"name": "Heun",
										"aliases": [
											"k_heun"
										],
										"options": {}
									},
									{
										"name": "DPM2",
										"aliases": [
											"k_dpm_2"
										],
										"options": {}
									},
									{
										"name": "DPM++ 2M",
										"aliases": [
											"k_dpmpp_2m"
										],
										"options": {}
									}
								]
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Gets a list of supported samplers",
				"tags": [
					"sdapi/v1"
				]
			}
		},
		"/sdapi/v1/loras": {
			"get": {
				"summary": "List available image LoRAs",
				"description": "Returns non-preloaded LoRAs available to the image backend.",
				"tags": [
					"sdapi/v1"
				],
				"responses": {
					"200": {
						"description": "Available LoRAs.",
						"content": {
							"application/json": {
								"schema": {
									"type": "array",
									"items": {
										"type": "object",
										"properties": {
											"name": {
												"type": "string"
											},
											"path": {
												"type": "string"
											}
										},
										"required": [
											"name",
											"path"
										]
									}
								}
							}
						}
					}
				}
			}
		},
		"/sdapi/v1/upscalers": {
			"get": {
				"summary": "List available image upscalers",
				"tags": [
					"sdapi/v1"
				],
				"responses": {
					"200": {
						"description": "The ESRGAN upscaler when configured, otherwise an empty list.",
						"content": {
							"application/json": {
								"schema": {
									"type": "array",
									"items": {
										"type": "object",
										"properties": {
											"name": {
												"type": "string"
											},
											"model_name": {
												"type": "string"
											},
											"model_path": {
												"type": "string"
											},
											"model_url": {
												"type": "string",
												"nullable": true
											},
											"scale": {
												"type": "integer"
											}
										}
									}
								}
							}
						}
					}
				}
			}
		},
		"/sdapi/v1/schedulers": {
			"get": {
				"summary": "List supported image schedulers",
				"tags": [
					"sdapi/v1"
				],
				"responses": {
					"200": {
						"description": "Available schedulers and configured custom sigma schedules.",
						"content": {
							"application/json": {
								"schema": {
									"type": "array",
									"items": {
										"type": "object",
										"properties": {
											"name": {
												"type": "string"
											},
											"label": {
												"type": "string"
											}
										},
										"required": [
											"name",
											"label"
										]
									}
								}
							}
						}
					}
				}
			}
		},
		"/sdapi/v1/latent-upscale-modes": {
			"get": {
				"summary": "List latent upscale modes",
				"description": "KoboldCpp does not provide latent upscale modes, so this endpoint returns an empty list.",
				"tags": [
					"sdapi/v1"
				],
				"responses": {
					"200": {
						"description": "An empty list.",
						"content": {
							"application/json": {
								"schema": {
									"type": "array",
									"items": {
										"type": "object"
									}
								}
							}
						}
					}
				}
			}
		},
		"/sdapi/v1/progress": {
			"get": {
				"summary": "Get image generation progress",
				"description": "Returns active progress only when genkey matches the current image generation; otherwise returns the idle state.",
				"tags": [
					"sdapi/v1"
				],
				"parameters": [
					{
						"name": "genkey",
						"in": "query",
						"required": false,
						"schema": {
							"type": "string"
						},
						"description": "Generation key returned for the active request."
					},
					{
						"name": "skip_current_image",
						"in": "query",
						"required": false,
						"schema": {
							"type": "boolean",
							"default": false
						},
						"description": "Do not request a base64 preview image."
					}
				],
				"responses": {
					"200": {
						"description": "AUTOMATIC1111-compatible progress information.",
						"content": {
							"application/json": {
								"schema": {
									"type": "object",
									"properties": {
										"progress": {
											"type": "number"
										},
										"eta_relative": {
											"type": "number"
										},
										"state": {
											"type": "object",
											"properties": {
												"job_count": {
													"type": "integer"
												},
												"job_no": {
													"type": "integer"
												},
												"sampling_step": {
													"type": "integer"
												},
												"sampling_steps": {
													"type": "integer"
												},
												"interrupted": {
													"type": "boolean"
												},
												"skipped": {
													"type": "boolean"
												}
											}
										},
										"current_image": {
											"type": "string",
											"nullable": true
										},
										"textinfo": {
											"type": "string",
											"nullable": true
										}
									},
									"required": [
										"progress",
										"eta_relative",
										"state",
										"current_image",
										"textinfo"
									]
								}
							}
						}
					}
				}
			}
		},
		"/sdapi/v1/get_last.json": {
			"get": {
				"summary": "Retrieve the cached result of an image generation",
				"description": "Returns the cached image-generation response when genkey matches the most recently cached request.",
				"tags": [
					"sdapi/v1"
				],
				"parameters": [
					{
						"name": "genkey",
						"in": "query",
						"required": true,
						"schema": {
							"type": "string"
						}
					}
				],
				"responses": {
					"200": {
						"description": "Cached generation result.",
						"content": {
							"application/json": {
								"schema": {
									"type": "object",
									"additionalProperties": true
								}
							}
						}
					},
					"404": {
						"description": "No cached result matches the supplied generation key."
					}
				}
			}
		},
		"/sdapi/v1/extra-single-image": {
			"$ref": "#/paths/~1sdapi~1v1~1upscale"
		},
		"/sdapi/v1/txt2img": {
			"post": {
				"description": "Generates an image from a text prompt, and returns a base64 encoded png.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"prompt": "picture of a kobold, high quality HD render",
								"negative_prompt": "ugly, deformed, censored",
								"cfg_scale": 5,
								"steps": 20,
								"width": 512,
								"height": 512,
								"seed": -1,
								"clip_skip": -1,
								"sampler_name": "Euler"
							},
							"schema": {
								"properties": {
									"prompt": {
										"type": "string"
									},
									"negative_prompt": {
										"type": "string"
									},
									"cfg_scale": {
										"type": "number"
									},
									"steps": {
										"type": "number"
									},
									"width": {
										"type": "number"
									},
									"height": {
										"type": "number"
									},
									"seed": {
										"type": "number"
									},
									"clip_skip": {
										"type": "number"
									},
									"sampler_name": {
										"type": "string"
									},
									"extra_images": {
										"type": "array",
										"items": {
											"type": "string"
										},
										"description": "KCPP only. Used for photomaker and Flux Kontext, to add extra b64 reference images."
									}
								},
								"type": "object"
							}
						}
					},
					"required": false
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"images": [
										"base64_image_data"
									],
									"parameters": {},
									"info": "{}",
									"animated": false,
									"extra_data": "",
									"final_frame": ""
								},
								"schema": {
									"properties": {
										"images": {
											"type": "array",
											"items": {
												"type": "string"
											},
											"description": "Base64 strings containing the encoded generated images. KoboldCpp currently returns one main image."
										},
										"parameters": {
											"type": "object",
											"description": "Not used. Will be empty."
										},
										"info": {
											"type": "string",
											"description": "A stringified JSON object containing generation information."
										},
										"animated": {
											"type": "boolean",
											"description": "Whether the generated output is animated."
										},
										"extra_data": {
											"type": "string",
											"description": "Additional base64 encoded output data when supplied by the image backend."
										},
										"final_frame": {
											"type": "string",
											"description": "Base64 encoded final frame when supplied by the image backend."
										}
									},
									"required": [
										"images",
										"parameters",
										"info",
										"animated",
										"extra_data",
										"final_frame"
									],
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Generates an image from a text prompt",
				"tags": [
					"sdapi/v1"
				]
			}
		},
		"/sdapi/v1/img2img": {
			"post": {
				"description": "Transforms an existing image into a new image, guided by a text prompt, and returns a base64 encoded png.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"prompt": "picture of a kobold, high quality HD render",
								"negative_prompt": "ugly, deformed, censored",
								"cfg_scale": 5,
								"steps": 20,
								"width": 512,
								"height": 512,
								"seed": -1,
								"clip_skip": -1,
								"sampler_name": "Euler",
								"denoising_strength": 0.6,
								"init_images": [],
								"mask": "",
								"inpainting_mask_invert": 0
							},
							"schema": {
								"properties": {
									"prompt": {
										"type": "string"
									},
									"negative_prompt": {
										"type": "string"
									},
									"cfg_scale": {
										"type": "number"
									},
									"steps": {
										"type": "number"
									},
									"width": {
										"type": "number"
									},
									"height": {
										"type": "number"
									},
									"seed": {
										"type": "number"
									},
									"clip_skip": {
										"type": "number"
									},
									"sampler_name": {
										"type": "string"
									},
									"denoising_strength": {
										"type": "number"
									},
									"init_images": {
										"type": "array",
										"items": {
											"type": "string"
										}
									},
									"mask": {
										"type": "string"
									},
									"inpainting_mask_invert": {
										"type": "integer"
									},
									"extra_images": {
										"type": "array",
										"items": {
											"type": "string"
										},
										"description": "KCPP only. Used for photomaker and Flux Kontext, to add extra b64 reference images."
									}
								},
								"type": "object"
							}
						}
					},
					"required": false
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"images": [
										"base64_image_data"
									],
									"parameters": {},
									"info": "{}",
									"animated": false,
									"extra_data": "",
									"final_frame": ""
								},
								"schema": {
									"properties": {
										"images": {
											"type": "array",
											"items": {
												"type": "string"
											},
											"description": "Base64 strings containing the encoded generated images. KoboldCpp currently returns one main image."
										},
										"parameters": {
											"type": "object",
											"description": "Not used. Will be empty."
										},
										"info": {
											"type": "string",
											"description": "A stringified JSON object containing generation information."
										},
										"animated": {
											"type": "boolean",
											"description": "Whether the generated output is animated."
										},
										"extra_data": {
											"type": "string",
											"description": "Additional base64 encoded output data when supplied by the image backend."
										},
										"final_frame": {
											"type": "string",
											"description": "Base64 encoded final frame when supplied by the image backend."
										}
									},
									"required": [
										"images",
										"parameters",
										"info",
										"animated",
										"extra_data",
										"final_frame"
									],
									"type": "object"
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Transforms an existing image into a new image",
				"tags": [
					"sdapi/v1"
				]
			}
		},
		"/sdapi/v1/interrogate": {
			"post": {
				"description": "Generates a short text caption describing an image.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"image": "base64_image_data",
								"model": "clip"
							},
							"schema": {
								"properties": {
									"image": {
										"type": "string",
										"description": "A base64 string containing the encoded PNG of the image."
									},
									"model": {
										"type": "string",
										"description": "Not used."
									}
								},
								"type": "object"
							}
						}
					},
					"required": false
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"caption": "A picture of a white cottage with a flagpole."
								},
								"schema": {
									"properties": {
										"caption": {
											"type": "string",
											"description": "A short text description of the image."
										}
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Generates a short text caption describing an image",
				"tags": [
					"sdapi/v1"
				]
			}
		},
		"/sdapi/v1/upscale": {
			"post": {
				"description": "Upscales an image with ESRGAN, increasing its resolution.",
				"requestBody": {
					"content": {
						"application/json": {
							"example": {
								"image": "base64_image_data",
								"upscaling_resize": 2
							},
							"schema": {
								"properties": {
									"image": {
										"type": "string",
										"description": "A base64 string containing the encoded PNG of the image."
									},
									"upscaling_resize": {
										"type": "integer",
										"description": "Integer upscale factor. Defaults to 2."
									}
								},
								"type": "object"
							}
						}
					},
					"required": false
				},
				"responses": {
					"200": {
						"content": {
							"application/json": {
								"example": {
									"html_info": "string",
									"image": "base64_image_data"
								},
								"schema": {
									"properties": {
										"html_info": {
											"type": "string",
											"description": "Not important."
										},
										"image": {
											"type": "string",
											"description": "Base64 encoded image data"
										}
									}
								}
							}
						},
						"description": "Successful request"
					}
				},
				"summary": "Upscales an image with ESRGAN, increasing its resolution.",
				"tags": [
					"sdapi/v1"
				]
			}
		}
	},
	"servers": [
		{
			"url": "/"
		}
	],
	"tags": [
		{
			"description": "OpenAI Compatible and Anthropic APIs. Recommended for beginners.",
			"name": "v1"
		},
		{
			"description": "KoboldAI United compatible API core endpoints",
			"name": "api/v1"
		},
		{
			"description": "Extended API unique to KoboldCpp",
			"name": "api/extra"
		},
		{
			"description": "Administrative model/configuration and KV-state operations. These endpoints require admin mode and use the --adminpassword Bearer credential when configured.",
			"name": "api/admin"
		},
		{
			"description": "Image Generation API (A1111 compatible)",
			"name": "sdapi/v1"
		},
		{
			"description": "Basic Ollama-compatible text generation and model discovery endpoints",
			"name": "ollama"
		},
		{
			"description": "Minimal JSON-RPC proxy for tools exposed by configured MCP servers",
			"name": "mcp"
		},
		{
			"description": "Common identity API for LLM services",
			"name": "serviceinfo"
		}
	]
}