> ## Documentation Index
> Fetch the complete documentation index at: https://io-migration.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Create Chat Completion

> Creates a model response for the given chat conversation.



## OpenAPI

````yaml openapi/create-chat-completion.json post /api/v1/chat/completions
openapi: 3.1.0
info:
  title: IO Intelligence
  version: '1.0'
servers:
  - url: https://api.intelligence.io.solutions
security:
  - sec0: []
paths:
  /api/v1/chat/completions:
    post:
      summary: Create Chat Completion
      description: Creates a model response for the given chat conversation.
      operationId: create-chat-completion
      requestBody:
        content:
          application/json:
            schema:
              type: object
              required:
                - model
                - messages
              properties:
                model:
                  type: string
                  description: >-
                    ID of the model to use. See the model endpoint compatibility
                    table for details on which models work with the Chat API.
                messages:
                  type: array
                  description: The conversation history
                reasoning_content:
                  type: boolean
                  description: Enable reasoning content in response
                  default: false
                frequency_penalty:
                  type: integer
                  description: >-
                    Number between -2.0 and 2.0. Positive values penalize new
                    tokens based on their existing frequency in the text so far,
                    decreasing the model's likelihood to repeat the same line
                    verbatim.
                  default: 0
                  format: int32
                logit_bias:
                  type: object
                  description: >-
                    Modify the likelihood of specified tokens appearing in the
                    completion.  Accepts a JSON object that maps tokens
                    (specified by their token ID in the tokenizer) to an
                    associated bias value from -100 to 100. Mathematically, the
                    bias is added to the logits generated by the model prior to
                    sampling. The exact effect will vary per model, but values
                    between -1 and 1 should decrease or increase likelihood of
                    selection; values like -100 or 100 should result in a ban or
                    exclusive selection of the relevant token.
                  properties: {}
                logprobs:
                  type: boolean
                  description: >-
                    Whether to return log probabilities of the output tokens or
                    not. If true, returns the log probabilities of each output
                    token returned in the content of message.
                  default: false
                top_logprobs:
                  type: integer
                  description: >-
                    An integer between 0 and 20 specifying the number of most
                    likely tokens to return at each token position, each with an
                    associated log probability. logprobs must be set to true if
                    this parameter is used.
                  format: int32
                max_tokens:
                  type: integer
                  description: >-
                    Deprecated. The maximum number of tokens that can be
                    generated in the chat completion. This value can be used to
                    control costs for text generated via API.  This value is now
                    deprecated in favor of max_completion_tokens, and is not
                    compatible with o1 series models.
                  format: int32
                max_completion_tokens:
                  type: integer
                  description: >-
                    An upper bound for the number of tokens that can be
                    generated for a completion, including visible output tokens
                    and reasoning tokens.
                  format: int32
                'n':
                  type: integer
                  description: >-
                    How many chat completion choices to generate for each input
                    message. Note that you will be charged based on the number
                    of generated tokens across all of the choices. Keep n as 1
                    to minimize costs.
                  default: 1
                  format: int32
                presence_penalty:
                  type: integer
                  description: >-
                    Number between -2.0 and 2.0. Positive values penalize new
                    tokens based on whether they appear in the text so far,
                    increasing the model's likelihood to talk about new topics.
                  default: 0
                  format: int32
                response_format:
                  type: object
                  description: >-
                    An object specifying the format that the model must output. 
                    Setting to { "type": "json_schema", "json_schema": {...} }
                    enables Structured Outputs which ensures the model will
                    match your supplied JSON schema. Learn more in the
                    Structured Outputs guide.  Setting to { "type":
                    "json_object" } enables JSON mode, which ensures the message
                    the model generates is valid JSON.  Important: when using
                    JSON mode, you must also instruct the model to produce JSON
                    yourself via a system or user message. Without this, the
                    model may generate an unending stream of whitespace until
                    the generation reaches the token limit, resulting in a
                    long-running and seemingly "stuck" request. Also note that
                    the message content may be partially cut off if
                    finish_reason="length", which indicates the generation
                    exceeded max_tokens or the conversation exceeded the max
                    context length.
                  properties: {}
                seed:
                  type: integer
                  description: >-
                    This feature is in Beta. If specified, our system will make
                    a best effort to sample deterministically, such that
                    repeated requests with the same seed and parameters should
                    return the same result. Determinism is not guaranteed, and
                    you should refer to the system_fingerprint response
                    parameter to monitor changes in the backend.
                  format: int32
                stop:
                  type: array
                  description: >-
                    Up to 4 sequences where the API will stop generating further
                    tokens.
                  items:
                    type: string
                stream:
                  type: boolean
                  description: >-
                    If set, partial message deltas will be sent, like in
                    ChatGPT. Tokens will be sent as data-only server-sent events
                    as they become available, with the stream terminated by a
                    data: [DONE] message. Example Python code.
                  default: false
                stream_options:
                  type: object
                  description: >-
                    Options for streaming response. Only set this when you set
                    stream: true.
                  properties: {}
                temperature:
                  type: integer
                  description: >-
                    What sampling temperature to use, between 0 and 2. Higher
                    values like 0.8 will make the output more random, while
                    lower values like 0.2 will make it more focused and
                    deterministic. We generally recommend altering this or top_p
                    but not both.
                  default: 0.7
                  format: int32
                top_p:
                  type: integer
                  description: >-
                    An alternative to sampling with temperature, called nucleus
                    sampling, where the model considers the results of the
                    tokens with top_p probability mass. So 0.1 means only the
                    tokens comprising the top 10% probability mass are
                    considered.  We generally recommend altering this or
                    temperature but not both.
                  default: 1
                  format: int32
                tools:
                  type: array
                  description: >-
                    A list of tools the model may call. Currently, only
                    functions are supported as a tool. Use this to provide a
                    list of functions the model may generate JSON inputs for. A
                    max of 128 functions are supported.
                tool_choice:
                  type: string
                  description: >-
                    Controls which (if any) tool is called by the model. none
                    means the model will not call any tool and instead generates
                    a message. auto means the model can pick between generating
                    a message or calling one or more tools. required means the
                    model must call one or more tools. Specifying a particular
                    tool via {"type": "function", "function": {"name":
                    "my_function"}} forces the model to call that tool.  none is
                    the default when no tools are present. auto is the default
                    if tools are present.
                  default: '"none"'
                parallel_tool_calls:
                  type: boolean
                  description: Whether to enable parallel function calling during tool use.
                  default: false
                user:
                  type: string
                  description: >-
                    A unique identifier representing your end-user, which can
                    help OpenAI to monitor and detect abuse.
                best_of:
                  type: integer
                  format: int32
                use_beam_search:
                  type: boolean
                  default: false
                top_k:
                  type: integer
                  default: -1
                  format: int32
                min_p:
                  type: integer
                  default: 0
                  format: int32
                repetition_penalty:
                  type: integer
                  default: 1
                  format: int32
                length_penalty:
                  type: integer
                  default: 1
                  format: int32
                stop_token_ids:
                  type: array
                  items:
                    type: integer
                    format: int32
                include_stop_str_in_output:
                  type: boolean
                  default: false
                ignore_eos:
                  type: boolean
                  default: false
                min_tokens:
                  type: integer
                  default: 0
                  format: int32
                skip_special_tokens:
                  type: boolean
                  default: true
                spaces_between_special_tokens:
                  type: boolean
                  default: true
                truncate_prompt_tokens:
                  type: integer
                  format: int32
                prompt_logprobs:
                  type: integer
                  format: int32
                echo:
                  type: boolean
                  description: >-
                    If true, the new message will be prepended with the last
                    message if they belong to the same role.
                  default: false
                add_generation_prompt:
                  type: boolean
                  description: >-
                    If true, the generation prompt will be added to the chat
                    template. This is a parameter used by chat template in
                    tokenizer config of the model.
                  default: true
                continue_final_message:
                  type: boolean
                  description: >-
                    If this is set, the chat will be formatted so that the final
                    message in the chat is open-ended, without any EOS tokens.
                    The model will continue this message rather than starting a
                    new one. This allows you to "prefill" part of the model's
                    response for it. Cannot be used at the same time as
                    add_generation_prompt.
                  default: false
                add_special_tokens:
                  type: boolean
                  description: >-
                    If true, special tokens (e.g. BOS) will be added to the
                    prompt on top of what is added by the chat template. For
                    most models, the chat template takes care of adding the
                    special tokens so this should be set to false (as is the
                    default).
                  default: false
                documents:
                  type: array
                  description: >-
                    A list of dicts representing documents that will be
                    accessible to the model if it is performing RAG
                    (retrieval-augmented generation). If the template does not
                    support RAG, this argument will have no effect. We recommend
                    that each document should be a dict containing "title" and
                    "text" keys.
                chat_template:
                  type: string
                  description: >-
                    A Jinja template to use for this conversion. As of
                    transformers v4.44, default chat template is no longer
                    allowed, so you must provide a chat template if the
                    tokenizer does not define one.
                chat_template_kwargs:
                  type: object
                  description: >-
                    Additional kwargs to pass to the template renderer. Will be
                    accessible by the chat template.
                  properties: {}
                guided_json:
                  type: string
                  description: If specified, the output will follow the JSON schema.
                guided_regex:
                  type: string
                  description: If specified, the output will follow the regex pattern.
                guided_choice:
                  type: array
                  description: If specified, the output will be exactly one of the choices.
                  items:
                    type: string
                guided_grammar:
                  type: string
                  description: >-
                    If specified, the output will follow the context free
                    grammar.
                guided_decoding_backend:
                  type: string
                  description: >-
                    If specified, will override the default guided decoding
                    backend of the server for this specific request. If set,
                    must be either 'outlines' / 'lm-format-enforcer'
                guided_whitespace_pattern:
                  type: string
                  description: >-
                    If specified, will override the default whitespace pattern
                    for guided json decoding.
                priority:
                  type: integer
                  description: >-
                    The priority of the request (lower means earlier handling;
                    default: 0). Any priority other than 0 will raise an error
                    if the served model does not use priority scheduling.
                  default: 0
                  format: int32
                request_id:
                  type: string
                  description: >-
                    The request_id related to this request. If the caller does
                    not set it, a random_uuid will be generated. This id is used
                    through out the inference process and return in response.
      responses:
        '200':
          description: '200'
          content:
            application/json:
              examples:
                Result:
                  value:
                    id: 0194e036-5a18-26ac-99d8-be455a6262b
                    object: chat.completion
                    created: 1738928445
                    model: CohereForAI/c4ai-command-r-plus-08-2024
                    choices:
                      - index: 0
                        message:
                          role: assistant
                          reasoning_content: null
                          content: Hi. How can I help?
                          tool_calls: []
                        logprobs: null
                        finish_reason: stop
                        stop_reason: null
                    usage:
                      prompt_tokens: 17
                      total_tokens: 25
                      completion_tokens: 8
                      prompt_tokens_details: null
                    prompt_logprobs: null
              schema:
                type: object
                properties:
                  id:
                    type: string
                    example: 0194e036-5a18-26ac-99d8-be455a6262b
                  object:
                    type: string
                    example: chat.completion
                  created:
                    type: integer
                    example: 1738928445
                    default: 0
                  model:
                    type: string
                    example: CohereForAI/c4ai-command-r-plus-08-2024
                  choices:
                    type: array
                    items:
                      type: object
                      properties:
                        index:
                          type: integer
                          example: 0
                          default: 0
                        message:
                          type: object
                          properties:
                            role:
                              type: string
                              example: assistant
                            reasoning_content: {}
                            content:
                              type: string
                              example: Hi. How can I help?
                            tool_calls:
                              type: array
                        logprobs: {}
                        finish_reason:
                          type: string
                          example: stop
                        stop_reason: {}
                  usage:
                    type: object
                    properties:
                      prompt_tokens:
                        type: integer
                        example: 17
                        default: 0
                      total_tokens:
                        type: integer
                        example: 25
                        default: 0
                      completion_tokens:
                        type: integer
                        example: 8
                        default: 0
                      prompt_tokens_details: {}
                  prompt_logprobs: {}
        '404':
          description: '404'
          content:
            application/json:
              examples:
                Result:
                  value: string
              schema:
                type: string
                example: string
        '422':
          description: '422'
          content:
            application/json:
              examples:
                Validation Error:
                  value:
                    detail:
                      - loc:
                          - string
                          - 0
                        msg: string
                        type: string
              schema:
                type: object
                properties:
                  detail:
                    type: array
                    items:
                      type: object
                      properties:
                        loc:
                          type: array
                        msg:
                          type: string
                          example: string
                        type:
                          type: string
                          example: string
      deprecated: false
      security: []
components:
  securitySchemes:
    sec0:
      type: oauth2
      flows: {}

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.