Text Generation

Text generation covers chat-style completions: summarizing, rewriting, translating, classifying, and generating free text from natural-language instructions. It is the model kind behind the CKEditor AI Assistant in the HTML editor and behind general-purpose chat completions for your own integrations.

Model

Model ID	adito-llm
Base model	Qwen3.6-35B-A3B, multimodal — accepts text and image input
Hosting	ADITO Cloud infrastructure, Germany
Base URL	https://ai.adito.cloud
Endpoint	/chat/completions
Interface	OpenAI-compatible Chat Completions API

Background and release context

For an overview of why the platform exists and how it is introduced, see AI is Part of ADITO Cloud. For the rollout of enable_thinking, see ADITO-LLM Now Supports Thinking.

info

The API uses the same request and response structure as the OpenAI API. You can use official OpenAI client libraries (such as openai for JavaScript/TypeScript) by changing only the base URL and API key.

Pinned versions

Codename	Base model	Status	Sunset / retired date
adito-llm-balzac	Qwen3.6-35B-A3B	Active (GA)	—
adito-llm-austen	Qwen3.5-35B-A3B-FP8	Deprecated	2026-08-31

The floating alias adito-llm currently points to adito-llm-balzac. Pin adito-llm-austen explicitly if your integration still needs the Qwen3.5 behavior before its retirement. See Model naming and versioning for how floating aliases and pinned codenames work.

What you can build

• Summarization — condense customer interactions, emails, or long notes into a few sentences.
• Rewriting — adjust tone or clarity of drafted text; this is what powers the CKEditor AI Assistant.
• Translation — translate free-text fields such as emails, notes, or product descriptions between languages. See the Prompting Guide for examples.
• Classification — sort emails, notes, or tickets by priority, topic, or team using guided_json to constrain the output to a schema.
• Structured AI outputs for automation — constrain any response to a defined JSON schema with guided_json so it flows directly into automated workflows or gets imported as a CRM entity, without manual parsing.
• CRM-aware prompts — include CRM data (accounts, opportunities, activities) in the messages array, for example to summarize a customer's history, suggest next actions, or draft emails from existing records.
• Natural-language task execution — combine CRM-aware prompts with function calling to let the model trigger CRM actions from plain-language instructions, e.g. "Create a quote based on this customer and their last opportunities."
• Scheduled record enrichment — call the API from a scheduled server process or ADITO web service to enrich records with summaries, keywords, or classifications on a schedule.
• Web scraping for context — pull external content via an MCP server or a custom web service and pass it alongside CRM data in the messages array when the CRM alone doesn't contain enough information.

Authentication

Every request requires an API key, passed as the apiKey parameter when initializing the client. Managed cloud systems receive a system API key automatically at startup. If you need a personal key, contact the AI team.

warning

Keep your API key confidential. Do not expose it in client-side code or public repositories.

Request parameters

The API follows the OpenAI chat completions format. The table below lists the most commonly used parameters.

Parameter	Type	Required	Description
model	String	Yes	Name of the model to use, e.g. adito-llm.
messages	Array	Yes	Array of message objects, each with a role and content field.
temperature	Number	No	Controls response creativity. Lower values produce more deterministic output.
max_tokens	Number	No	Maximum number of tokens in the response.
guided_json	Object	No	ADITO-specific. JSON schema that constrains the model output. See Guided JSON output.
chat_template_kwargs	Object	No	ADITO-specific. Extra keyword arguments forwarded to the model's chat template. Currently supports enable_thinking (boolean, default false) to enable thinking mode.

ADITO-specific parameter

guided_json is not the same as the standard OpenAI response_format parameter. It is an ADITO-specific extension that enforces a JSON schema on the model output at the inference level. Do not use response_format — use guided_json instead.

For a full list of supported parameters, refer to the OpenAI API documentation.

First how-to: basic chat completion

note

The code examples on this page are not JDito code. They illustrate general API usage and can be adapted to any language or HTTP client.

curl

curl https://ai.adito.cloud/chat/completions \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "adito-llm",
    "messages": [
      { "role": "system", "content": "You are a CRM assistant. Summarize customer interactions in two sentences." },
      { "role": "user", "content": "Customer Acme Corp had 3 calls last week about delayed shipments, followed by a meeting where a 10% discount was offered." }
    ],
    "temperature": 0.7
  }'

JavaScript

import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'https://ai.adito.cloud',
  apiKey: 'your-api-key'
});

async function getCompletion() {
  const response = await openai.chat.completions.create({
    model: 'adito-llm',
    messages: [
      { role: 'system', content: 'You are a CRM assistant. Summarize customer interactions in two sentences.' },
      { role: 'user', content: 'Customer Acme Corp had 3 calls last week about delayed shipments, followed by a meeting where a 10% discount was offered.' }
    ],
    temperature: 0.7
  });
  console.log(response.choices[0].message.content);
}

getCompletion();

Advanced usage

Guided JSON output

The API supports guided JSON output, which constrains the model response to match a defined JSON schema. This is useful when the result needs to be processed programmatically — for example, to create or update CRM records.

Click to expand guided JSON example

import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'https://ai.adito.cloud',
  apiKey: 'your-api-key'
});

async function classifyEmail() {
  const response = await openai.chat.completions.create({
    model: 'adito-llm',
    messages: [
      {
        role: 'system',
        content: 'You are a CRM email classifier. Analyze the email and return structured data.'
      },
      {
        role: 'user',
        content: `Classify this email:\n\nSubject: Urgent — production system down\nBody: Our main ERP integration has stopped syncing since this morning. We need immediate help. This is blocking 50+ users.`
      }
    ],
    temperature: 0.15,
    // guided_json is ADITO-specific — do not use response_format
    guided_json: {
      type: 'object',
      properties: {
        subject_summary: { type: 'string' },
        priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
        category: { type: 'string', enum: ['bug', 'feature_request', 'support', 'billing', 'other'] },
        suggested_team: { type: 'string' }
      },
      required: ['subject_summary', 'priority', 'category'],
      additionalProperties: false
    }
  });
  console.log(response.choices[0].message.content);
  // → {"subject_summary":"ERP integration sync failure","priority":"critical","category":"bug","suggested_team":"Integrations"}
}

classifyEmail();

Function calling and tool use

The API supports OpenAI-style function calling. You define tools as part of the request, and the model decides when to invoke them based on the conversation context.

The example below shows a CRM scenario: the user asks about a contact's recent activity, and the model calls two tools — one to look up activities and another to create a follow-up task.

Click to expand function calling example

import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'https://ai.adito.cloud',
  apiKey: 'your-api-key'
});

async function handleContactQuery() {
  const response = await openai.chat.completions.create({
    model: 'adito-llm',
    messages: [
      {
        role: 'system',
        content: 'You are a CRM assistant. Use the available tools to look up data and create records.'
      },
      {
        role: 'user',
        content: 'Show me the last 5 activities for contact "Maria Hoffmann" and create a follow-up call for next Monday.'
      }
    ],
    tools: [
      {
        type: 'function',
        function: {
          name: 'get_contact_activities',
          description: 'Retrieve recent activities for a CRM contact.',
          parameters: {
            type: 'object',
            properties: {
              contact_name: { type: 'string', description: 'Full name of the contact' },
              limit: { type: 'number', description: 'Maximum number of activities to return' }
            },
            required: ['contact_name']
          }
        }
      },
      {
        type: 'function',
        function: {
          name: 'create_activity',
          description: 'Create a new activity (call, meeting, task) in the CRM.',
          parameters: {
            type: 'object',
            properties: {
              contact_name: { type: 'string', description: 'Full name of the contact' },
              activity_type: { type: 'string', enum: ['call', 'meeting', 'task'], description: 'Type of activity' },
              subject: { type: 'string', description: 'Subject line for the activity' },
              due_date: { type: 'string', description: 'Due date in YYYY-MM-DD format' }
            },
            required: ['contact_name', 'activity_type', 'subject', 'due_date']
          }
        }
      }
    ],
    tool_choice: 'auto',
    temperature: 0.15
  });

  // Process tool calls from the response
  const toolCalls = response.choices[0].message.tool_calls;
  if (toolCalls) {
    toolCalls.forEach(call => {
      console.log(`Tool: ${call.function.name}, Args: ${call.function.arguments}`);
    });
  }
}

handleContactQuery();

Thinking mode

Thinking mode makes the model reason through the problem before responding. Use it when the task requires more than pattern-matching: complex classification, ambiguous inputs, or long documents where the model needs to work out an answer rather than retrieve one.

Enable it by adding chat_template_kwargs: { enable_thinking: true } to your request. The default is false. Existing requests are unaffected.

note

Thinking mode increases response latency and token usage. Enable it only for tasks where reasoning depth outweighs the cost.

tip

Combine thinking mode with a low temperature (0.1–0.2) for deterministic reasoning output.

curl

curl https://ai.adito.cloud/chat/completions \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "adito-llm",
    "chat_template_kwargs": { "enable_thinking": true },
    "messages": [
      {
        "role": "system",
        "content": "You are a CRM analyst. Analyse the support case and determine root cause, urgency, and recommended action."
      },
      {
        "role": "user",
        "content": "Customer reports intermittent login failures since last Friday. Affects roughly 30% of users. No error message shown — the login form just resets. Backend logs show no authentication errors."
      }
    ],
    "temperature": 0.15
  }'

JavaScript

import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'https://ai.adito.cloud',
  apiKey: 'your-api-key'
});

async function analyseWithThinking() {
  const response = await openai.chat.completions.create({
    model: 'adito-llm',
    chat_template_kwargs: { enable_thinking: true },
    messages: [
      {
        role: 'system',
        content: 'You are a CRM analyst. Analyse the support case and determine root cause, urgency, and recommended action.'
      },
      {
        role: 'user',
        content: 'Customer reports intermittent login failures since last Friday. Affects roughly 30% of users. No error message shown — the login form just resets. Backend logs show no authentication errors.'
      }
    ],
    temperature: 0.15
  });
  console.log(response.choices[0].message.content);
}

analyseWithThinking();

Error handling

API requests can fail due to authentication errors, rate limits, or invalid parameters. Wrap your calls in a try/catch block and inspect the error response.

async function safeChatCompletion() {
  try {
    const response = await openai.chat.completions.create({
      model: 'adito-llm',
      messages: [
        { role: 'user', content: 'Summarize this account.' }
      ]
    });
    return response.choices[0].message.content;
  } catch (error) {
    // The OpenAI client throws an error with status and message
    console.error(`API error: ${error.status} — ${error.message}`);
    // Common status codes:
    //   401 — Invalid or missing API key
    //   429 — Rate limit exceeded, retry after a delay
    //   500 — Server error, retry or contact the AI team
  }
}

---

See also: Prompting Guide | AI Models