Kimi-K3.1-Pro

export DEVUP_API_KEY="YOUR_DEVUP_API_KEY"

$env:DEVUP_API_KEY = "YOUR_DEVUP_API_KEY"

{
  "model": "moonshotai/Kimi-K3.1-Pro",
  "messages": [
    {
      "role": "user",
      "content": "Reply with OK."
    }
  ],
  "reasoning_effort": "low",
  "max_tokens": 4096,
  "stream": false
}

curl --request POST "https://api.devupai.com/v1/chat/completions" \
  --connect-timeout 20 \
  --max-time 300 \
  --header "Authorization: Bearer $DEVUP_API_KEY" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import json
import os
from urllib.error import HTTPError
from urllib.request import Request, urlopen

MODEL = "moonshotai/Kimi-K3.1-Pro"
ENDPOINT = "https://api.devupai.com/v1/chat/completions"


def complete(messages, **options):
    payload = {
        "model": MODEL,
        "messages": messages,
        "reasoning_effort": "low",
        "max_tokens": 4096,
        "stream": False,
        **options,
    }
    request = Request(
        ENDPOINT,
        data=json.dumps(payload).encode("utf-8"),
        headers={
            "Authorization": f"Bearer {os.environ['DEVUP_API_KEY']}",
            "Content-Type": "application/json",
        },
        method="POST",
    )

    try:
        with urlopen(request, timeout=300) as response:
            return json.load(response)
    except HTTPError as error:
        detail = error.read().decode("utf-8", errors="replace")
        request_id = error.headers.get("x-request-id", "unavailable")
        raise RuntimeError(
            f"HTTP {error.code}; request_id={request_id}; body={detail}"
        ) from error

from devup_client import complete

response = complete([
    {"role": "user", "content": "Reply with OK."}
])

print(response["choices"][0]["message"]["content"])

python quickstart.py

OK

const response = await fetch(
  "https://api.devupai.com/v1/chat/completions",
  {
    method: "POST",
    signal: AbortSignal.timeout(300_000),
    headers: {
      Authorization: `Bearer ${process.env.DEVUP_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "moonshotai/Kimi-K3.1-Pro",
      messages: [{ role: "user", content: "Reply with OK." }],
      reasoning_effort: "low",
      max_tokens: 4096,
      stream: false,
    }),
  },
);

const result = await response.json();

if (!response.ok) {
  throw new Error(
    JSON.stringify({
      status: response.status,
      request_id: response.headers.get("x-request-id"),
      error: result.error,
    }),
  );
}

console.log(result.choices[0].message.content);

node quickstart.mjs

OK

from devup_client import complete

response = complete(
    [{"role": "user", "content": "What is the least common multiple of 1 through 12?"}],
    reasoning_effort="none",
)

message = response["choices"][0]["message"]
usage = response["usage"]

print(message["content"])
print(usage.get("completion_tokens_details", {}).get("reasoning_tokens"))

Answer: 27,720
Reported reasoning tokens: 0

from devup_client import complete

response = complete(
    [{"role": "user", "content": "Explain why the least common multiple of 1 through 12 is 27720."}],
    reasoning_effort="high",
)

message = response["choices"][0]["message"]
reasoning = message.get("reasoning_content") or ""
answer = message.get("content") or ""

print(answer)
print(f"Reasoning characters returned: {len(reasoning)}")

curl --no-buffer --request POST \
  "https://api.devupai.com/v1/chat/completions" \
  --connect-timeout 20 \
  --max-time 300 \
  --header "Authorization: Bearer $DEVUP_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "moonshotai/Kimi-K3.1-Pro",
    "messages": [{"role": "user", "content": "Reply with OK."}],
    "reasoning_effort": "low",
    "max_tokens": 4096,
    "stream": true
  }'

data: {"choices":[{"delta":{"content":"OK"},"finish_reason":null}]}

data: {"choices":[{"delta":{"content":null},"finish_reason":"stop"}]}

data: {"choices":[],"usage":{"prompt_tokens":93,"completion_tokens":28,"total_tokens":121}}

data: [DONE]

{
  "type": "function",
  "function": {
    "name": "get_test_weather"
  }
}

import json
from devup_client import complete

tools = [{
    "type": "function",
    "function": {
        "name": "get_test_weather",
        "description": "Return synthetic weather data for an integration example.",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
            "additionalProperties": False,
        },
    },
}]

messages = [{
    "role": "user",
    "content": "Call get_test_weather for Algiers. Do not invent the tool result.",
}]

first = complete(messages, tools=tools, tool_choice="required")
assistant = first["choices"][0]["message"]

# Preserve the complete returned message, including reasoning and tool calls.
messages.append(assistant)

calls = assistant.get("tool_calls") or []
if not calls:
    raise RuntimeError("Expected a function call.")

for call in calls:
    function = call["function"]
    arguments = json.loads(function["arguments"])

    if function["name"] != "get_test_weather":
        raise ValueError("Unexpected function name.")
    if arguments != {"city": "Algiers"}:
        raise ValueError("Unexpected function arguments.")

    messages.append({
        "role": "tool",
        "tool_call_id": call["id"],
        "content": json.dumps({
            "city": "Algiers",
            "temperature_c": 22,
            "source": "synthetic_test_data",
        }),
    })

messages.append({
    "role": "user",
    "content": "What temperature did the test tool return? Answer with the number only.",
})

final = complete(messages, tools=tools, tool_choice="none")
print(final["choices"][0]["message"]["content"])

22

import json
from devup_client import complete

response = complete(
    [{
        "role": "user",
        "content": 'Return exactly one JSON object with city="Algiers" and count=3. No other fields.',
    }],
    response_format={"type": "json_object"},
)

data = json.loads(response["choices"][0]["message"]["content"])
assert data == {"city": "Algiers", "count": 3}
print(data)

{
  "city": "Algiers",
  "count": 3
}

import json
from devup_client import complete

schema = {
    "type": "object",
    "properties": {
        "city": {"type": "string", "enum": ["Algiers"]},
        "count": {"type": "integer", "enum": [3]},
    },
    "required": ["city", "count"],
    "additionalProperties": False,
}

response = complete(
    [{
        "role": "user",
        "content": 'Return city="Algiers" and count=3 using the supplied schema.',
    }],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "integration_test",
            "strict": True,
            "schema": schema,
        },
    },
)

data = json.loads(response["choices"][0]["message"]["content"])
assert set(data) == {"city", "count"}
assert data["city"] == "Algiers"
assert type(data["count"]) is int and data["count"] == 3
print(data)

{
  "city": "Algiers",
  "count": 3
}

import base64
from pathlib import Path
from devup_client import complete

image_bytes = Path("image.png").read_bytes()
image_data = base64.b64encode(image_bytes).decode("ascii")

response = complete([{
    "role": "user",
    "content": [
        {
            "type": "text",
            "text": (
                "Read the verification code in the image exactly. "
                "Identify the two colored shapes from left to right. "
                "Return only JSON with code, left_shape, left_color, "
                "right_shape, and right_color."
            ),
        },
        {
            "type": "image_url",
            "image_url": {
                "url": f"data:image/png;base64,{image_data}",
            },
        },
    ],
}])

print(response["choices"][0]["message"]["content"])

{
  "code": "9A4DDAAB",
  "left_shape": "rectangle",
  "left_color": "red",
  "right_shape": "circle",
  "right_color": "blue"
}

import base64
from pathlib import Path
from devup_client import complete

pdf_bytes = Path("verification.pdf").read_bytes()
pdf_data = base64.b64encode(pdf_bytes).decode("ascii")

response = complete([{
    "role": "user",
    "content": [
        {
            "type": "text",
            "text": (
                "Read the attached PDF. Return only JSON with code, "
                "quantity, unit_price, and total. Copy the verification "
                "code exactly. Calculate total as quantity multiplied "
                "by unit price."
            ),
        },
        {
            "type": "file",
            "file": {
                "filename": "verification.pdf",
                "file_data": f"data:application/pdf;base64,{pdf_data}",
            },
        },
    ],
}])

print(response["choices"][0]["message"]["content"])

{
  "code": "72DA5EA6",
  "quantity": 9,
  "unit_price": 38,
  "total": 342
}