Tchavi
ModelsPricingDocumentationBlog
Tchavi
  • Why Tchavi
  • Models
  • Pricing

Contact us

  • Email: support@tchavi.com
  • Support
  • Frontier AI, paid with mobile money. No card, no KYC.

Resources

  • API Reference
  • Documentation
  • Blog

Legal

  • Privacy
  • Terms of Service

© 2026 Tchavi. All rights reserved.

We use cookies to enhance your experience, provide personalised content, and analyse our traffic; see our Cookie Policy.

Back to models
C

Command A+

cohere/command-a-plus

Answers drawn from your documents, with the source cited

Command A+ is the last model in Cohere's Command A family, released in May 2026 under the Apache 2.0 licence. It brings vision, reasoning and tool use together in one model and, according to Cohere, covers 48 languages.

Modalities
Input / Output
0.659 / 3.293cr / 1K
Context window
128K
Released
May 20, 2026
Capabilities
  • Tools
  • JSON mode
  • Vision
  • Streaming
  • Prompt caching· read 0.33 cr / 1K

It is at its best answering from a text you supply and citing the article it relied on: terms of sale, internal procedures, FAQs. In our tests it also said plainly what the text did not allow. It reads images, calls tools and returns JSON, after a short think: 2 to 8 seconds per answer.

On Tchavi you pay with mobile money, with no international card and no KYC, and one API key covers 80+ models. It is OpenAI-compatible: change the base URL, keep your SDK.

What this model does well

  • 📑

    Cited answers

    Answers from your documents and cites the article it used

  • 🌍

    48 languages, per Cohere

    English, French, Portuguese and Spanish among them

  • 🧠

    Thinks before answering

    A few hundred reasoning tokens per answer

  • 👁️

    Reads images

    Screenshots, purchase orders and photos alongside your text

  • 🛠️

    Tools and JSON mode

    Function calling and structured output

  • 📚

    128K-token context

    128K tokens in and 64K out, according to Cohere

Example prompts

  • Using these staff rules, answer an employee's question and cite the article you relied on.

  • Read this photo of a purchase order and return its lines as JSON: product, quantity, price.

  • Summarise this report in five points and give the section each figure comes from.

Good to know

  • One language per request: in our tests, asking for English, Portuguese and Arabic at once put Arabic under the English heading, three times out of three.
  • tool_choice is supported only as "auto": the model decides whether to call a tool, and "required" is refused.
  • Its 128K-token context is shorter than other models in the catalogue: for a very long document, pick Command A or Mistral Large 4.

Technical specifications

Author
Cohere
API identifier
command-a-plus
Category
Chat & Text
Context window
128,000 tokens
Max output
64,000 tokens
Rate limit
120 RPM
Billing unit
token
Streaming
Yes

Ideal for

  • Assistant over your documents
  • Cited FAQ and support answers
  • Reading contracts and terms
  • Tool-calling agents
  • Analysing images and screenshots

Ready to try it?

Test this model in the playground, no setup needed.

Frequently asked questions

Command A+ or Command A?

Command A+ is the next generation: it adds vision, reasoning and tool use, for far less. Command A (model: "command-a") keeps a longer context, 256K tokens.

Can it translate into several languages at once?

Better to send one request per language. In our tests, asking for English, Portuguese and Arabic in the same answer put Arabic under the English heading, three times out of three.

How does tool calling work?

Send your tools as with the OpenAI API: the model decides whether to call one. tool_choice: "auto" is accepted; "required", "none" or a forced tool are refused with an unsupported_parameter error.

Does it read images and PDFs?

Images, yes. For a PDF, extract the text first, or pick a model that accepts documents.

How do I call Command A+ with my OpenAI SDK?

Point the base URL at Tchavi, use your Tchavi key and set model: "command-a-plus" on /v1/chat/completions. The rest of your code stays the same.

Can I pay with mobile money, without a bank card?

Yes. Top up your Tchavi account with Orange Money, MTN MoMo, M-Pesa or another mobile money operator. No bank card is needed. Credits land as soon as the payment is confirmed and are deducted as you use them.

Is the API compatible with OpenAI's?

Yes. Keep your current OpenAI SDK, just change the base URL to Tchavi's (shown in the API tab) and use your Tchavi key. The rest of your code stays the same.

API

import Tchavi from '@tchavi/sdk';

const client = new Tchavi({ apiKey: 'API_KEY' });

const response = await client.chat.completions.create({
  model: 'command-a-plus',
  messages: [
  {
    "role": "user",
    "content": "Hello!"
  }
],
});

console.log(response.choices[0].message.content);
console.log('Credits used:', response.tchavi.credits_used);

API parameters

Every parameter this model accepts on the API. Check the SDK for full typings.

modelRequired
string

ID of the chat model (e.g. `command-a-plus`).

messagesRequired
Array<{ role, content }>

Conversation messages. Each item has a `role` (system/user/assistant) and a `content` that's either a plain string or an array of content blocks (`text`, `image_url`, `document_url`).

temperature
number
Default: 1

Sampling temperature between 0 and 2. Higher values = more random.

max_tokens
integer

Maximum number of tokens to generate in the response.

max_completion_tokens
integer

OpenAI alias for `max_tokens`. Either field works; if both are sent, `max_completion_tokens` wins.

stream
boolean
Default: false

If true, partial message deltas are streamed as Server-Sent Events.

tools
Array<{ type, function }>

Function-calling toolbox. Pass an array of `{ type: "function", function: { name, description, parameters } }`. Returned tool calls land in `choices[].message.tool_calls`. Only models with `supportsTools: true` accept this.

tool_choice
"auto" | "none" | { type, function }

How the model picks among tools: `"auto"` (default), `"none"` to force a plain text reply, or `{ type: "function", function: { name } }` to force a specific tool. Only with `supportsTools: true`.

response_format
{ type: "json_object" | "text" }

Constrain the output. Pass `{ type: "json_object" }` to force valid JSON (the model still needs a JSON instruction in your prompt). Only models with `supportsJsonMode: true` honour this.

Show all parameters (19)
top_p
number
Default: 1

Nucleus sampling: only tokens in the top `top_p` probability mass are considered.

seed
integer

Integer seed for deterministic output. The same seed + identical request yields the same completion when supported by the provider. OpenAI honours it; Anthropic ignores.

n
integer
Default: 1

Number of completions to generate in one call. Defaults to 1; each extra completion is billed.

stream_options
{ include_usage?: boolean }

Streaming options, e.g. `{ "include_usage": true }` to receive a final SSE chunk with usage counts. Effective only when `stream: true`.

stop
string | string[]

Up to 4 sequences where the API will stop generating further tokens.

frequency_penalty
number
Default: 0

Between -2.0 and 2.0. Positive values penalize tokens that have appeared frequently.

presence_penalty
number
Default: 0

Between -2.0 and 2.0. Positive values encourage the model to talk about new topics.

user
string

End-user identifier passed to the upstream provider for abuse / moderation tracking. Should be stable per end-user.

logit_bias
Record<string, number>

Per-token logit bias `{ "<tokenId>": <-100..100>, ... }`. OpenAI-specific; Anthropic ignores silently.

messages[].content[].image_url
string

Attach an image on a user message. Pass a content block `{ "type": "image_url", "image_url": { "url": ... } }`. PNG / JPEG / WebP, up to 4 per request. Only models with `supportsImageInput: true` accept this block (e.g. `gpt-4o`, `claude-opus-4-7`).

Pricing

per 1,000 tokens
0.659 credits
Input 0.659 · Output 3.293 cr/1K

How billing works

  • Billed per token used, down to a thousandth of a credit.
  • A typical message (500 in, 150 out) costs about —, or 0.824 credits.
  • Prompt cache reads: — per 1K tokens (0.33 credits).
Real-world scenarios
Per day
Per week
Per month

Estimated over 30 days, for a typical message: ~500 input + ~150 output tokens, billed to the thousandth of a credit.

A 10 000 F CFA top-up gives you about ~36 411 questions. Pay with Orange Money, MTN MoMo or M-Pesa — no Visa card needed.

Ready to use Command A+?

Create your accountAPI Documentation

Bonus credits on your first top-up · No card to sign up