Using ALLSmartLLM

Three steps

1. Create an account at allsmartllm.com/en/login. After you confirm your e-mail we activate the account and let you know. Every new account starts with 10 million free tokens.
2. Create an API key in the control centre under Keys. Keys start with sk-allsmartllm- and are shown only once.
3. Send your first request:

   curl https://allsmartllm.com/v1/chat/completions \
     -H "Authorization: Bearer sk-allsmartllm-…" \
     -H "Content-Type: application/json" \
     -d '{
       "model": "mid",
       "messages": [{"role": "user", "content": "Hallo!"}]
     }'

Base URL and authentication

The key belongs in the header, never in a URL. Treat it like a password: don't commit it, don't ship it in client applications. Delete a compromised key in the control centre and create a new one.

OpenAI-compatible: your existing setup

You don't need a separate library. Any OpenAI SDK works with two changed values.

Python

from openai import OpenAI

client = OpenAI(
    base_url="https://allsmartllm.com/v1",
    api_key="sk-allsmartllm-…",
)

antwort = client.chat.completions.create(
    model="mid",
    messages=[{"role": "user", "content": "…"}],
)
print(antwort.choices[0].message.content)

JavaScript / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://allsmartllm.com/v1",
  apiKey: "sk-allsmartllm-…",
});

const antwort = await client.chat.completions.create({
  model: "mid",
  messages: [{ role: "user", content: "…" }],
});
console.log(antwort.choices[0].message.content);

Other tools (LangChain, LlamaIndex, Continue, Open WebUI, Cursor, …): wherever you can enter an OpenAI base URL, enter https://allsmartllm.com/v1.

Models and aliases

In model you can pass a concrete model ID or an alias. An alias is a stable role name such as mid or coder. We resolve it server-side to whichever model currently fills that role best. When we swap a model or change hardware, nothing changes in your code.

Our recommendation: use aliases. Concrete model IDs are for when you need to pin one specific model reproducibly.

Which alias for what

"Reasons?" is the default; you can override it per request (see below).

Fetch the current list live at any time:

curl https://allsmartllm.com/v1/aliases -H "Authorization: Bearer sk-allsmartllm-…"
curl https://allsmartllm.com/v1/models  -H "Authorization: Bearer sk-allsmartllm-…"

In /v1/models aliases appear alongside the real models, recognisable by "owned_by": "smartllm-alias". /v1/aliases is our extension and not part of the OpenAI specification.

Which models sit behind the aliases, with licence, quantisation, context length and an independent quality index, is shown in the model table.

Decision models (not chat)

Two models in the table work fundamentally differently from all the others: clef-flash and clef. They produce no text. You don't send them a prompt and you don't get sentences back.

Instead you give a state and up to 64 typed questions. The model reads both in a single pass and returns a probability for every answer option. That is fast (a decision with three questions takes about a second), and the result is machine-readable without parsing it out of a sentence.

Separate endpoint: POST /v1/systemone. On /v1/chat/completions these models answer with 400, and conversely /v1/systemone rejects ordinary chat models.

Three question types

• noul: true or false. The answer is a probability for “true”.
• choice: named options. The answer names the most likely one and gives the distribution over all.
• score: ordered levels. The answer is a value between the levels plus the distribution.

instructions is required on every question. Images are supported (base64, PNG/JPEG/WebP), not URLs.

curl https://allsmartllm.com/v1/systemone \
  -H "Authorization: Bearer sk-allsmartllm-…" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "clef-flash",
    "state": "Kunde will Rechnung storniert haben",
    "questions": {
      "intent": {"type": "choice", "instructions": "Was will der Kunde?",
                 "criteria": {"storno": "Stornierung", "frage": "Allgemeine Frage"}},
      "dringlichkeit": {"type": "score", "instructions": "Wie dringend?",
                        "criteria": ["kann warten", "diese Woche", "heute"]},
      "rechnung": {"type": "noul", "instructions": "Geht es um eine Rechnung?"}
    }
  }'

{
  "model": "clef-flash",
  "answers": {
    "intent":        {"type": "choice", "choice": "storno",
                      "probabilities": {"storno": 0.9898, "frage": 0.0102},
                      "confidence": 0.9179},
    "dringlichkeit": {"type": "score", "score": 1.23,
                      "legend": {"0": "kann warten", "1": "diese Woche", "2": "heute"},
                      "probabilities": {"0": 0.2777, "1": 0.2180, "2": 0.5043},
                      "confidence": 0.0597},
    "rechnung":      {"type": "noul", "noul": 0.9702}
  },
  "usage": {"input_tokens": 305, "output_tokens": 0}
}

About confidence: it is not the highest probability but a separate measure of how sharply the distribution concentrates on one option. In the example below the most likely level has 0.50 while confidence is only 0.06. The answer is barely settled, even though one option leads.

Only the input is billed: output_tokens is 0 in every answer.

Controlling reasoning ("thinking")

Many of our models can think before answering. That improves hard tasks and, on easy ones, only costs time and tokens. Every alias has a sensible default (table above); per request you override it like this:

{
  "model": "mid",
  "messages": [{"role": "user", "content": "…"}],
  "chat_template_kwargs": {"enable_thinking": false}
}

We accept three spellings as equivalent: chat_template_kwargs.enable_thinking (vLLM), top-level enable_thinking, and think (Ollama style). Your signal always wins over the alias default.

Two things worth knowing:

• max_tokens includes the thinking. A model that thinks for 1500 tokens and should then answer in 500 needs max_tokens of at least 2000. Set too low, you get empty content because the budget was spent on reasoning.
• The reasoning block is returned in the reasoning field, separate from content. When streaming, likewise in delta.reasoning.

For tasks that don't need thinking, pick the matching alias right away (worker, fast); then there's nothing to set.

Streaming

As with OpenAI: "stream": true returns server-sent events, each data: event is a JSON chunk with delta. The last event before [DONE] carries usage.

stream = client.chat.completions.create(
    model="mid",
    messages=[{"role": "user", "content": "…"}],
    stream=True,
)
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="", flush=True)

Images, tools, structured output

Images go in as an image_url content block, as a URL or a base64 data URL. Suitable: frontier, mid, vision.

{
  "model": "vision",
  "messages": [{
    "role": "user",
    "content": [
      {"type": "text", "text": "…"},
      {"type": "image_url", "image_url": {"url": "data:image/png;base64,…"}}
    ]
  }],
  "max_tokens": 1000
}

Tool calling (function calling) works with the OpenAI schema (tools, tool_choice, replies with tool_calls). Supported by frontier, mid, worker, coder, vision, fast, swift, judge. A model's capabilities are listed in /v1/models under capabilities.

Structured output via response_format, either json_object or json_schema with a schema. For decisions with fixed options, fast + a JSON schema with enum is the intended combination: fast, and the answer is guaranteed to be one of the allowed values.

{
  "model": "fast",
  "messages": [{"role": "user", "content": "…"}],
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "name": "kategorie",
      "schema": {
        "type": "object",
        "properties": {
          "kategorie": {"type": "string", "enum": ["a", "b", "c"]}
        },
        "required": ["kategorie"]
      }
    }
  }
}

Embeddings

curl https://allsmartllm.com/v1/embeddings \
  -H "Authorization: Bearer sk-allsmartllm-…" \
  -H "Content-Type: application/json" \
  -d '{"model": "embed", "input": ["…", "…"]}'

input takes a string or a list. Chat models on this endpoint respond with 400.

Priority and queueing

Our models run on finite hardware; under load we queue requests briefly rather than reject them. With the X-Priority header you tell us what's urgent:

If you mark your background load as low, your interactive requests get noticeably better response times. It's the same hardware.

Errors

Whether something is currently wrong you can see without logging in on the status page, including availability over the last 30 days, measured rather than claimed.

Every response carries an X-Request-ID header. When you report a problem, include it; that's how we find the request.

What we store and what we don't

Via the API no content is stored: neither your prompts nor the answers. We log timestamp, model, token counts, duration and status code, which is what has to appear on an invoice. The full list is on the home page; it comes from the log schema, not from marketing copy.

Everything runs on our own hardware in Austria. There is no third party your data is passed on to.

To go one step further: with "privacy": {"mode": "pseudonymize"} in the request we detect personal data (names, addresses, IBANs, …) and replace it with placeholders before the model sees the text; in the response we restore the originals. "mode": "mask" masks permanently, without restoration. Costs a small surcharge on input tokens.

Pricing

Billed per million tokens, input and output separately, by model category:

The 10 million free tokens of every new account are used up first. You can see your balance in the control centre under "Usage", and manage your billing address there too.

Reasoning tokens count as output. One more reason to use worker or fast for simple tasks.

Try it without code

The control centre has a Workbench: run prompts against several models at once, compare answers and cost. Nothing is stored there.

Help

Questions, problems, a model you're missing: Support. You reach the person who built the system, not a queue.