Does Codestral support tool calling?

No — Codestral is a code-specialist model and does not support the tool-calling schema. Use Mistral Large for code workflows that need to call tools.

What is the FIM endpoint?

The fill-in-the-middle endpoint at /v1/fim/completions takes a prefix and a suffix and asks Codestral to fill the gap. It matches Codestral's training objective and produces tighter completions than chat prompts asking for the same thing.

Which languages does Codestral cover?

80+ programming languages including Python, TypeScript, JavaScript, Java, C++, Go, Rust, Ruby, PHP, SQL, Bash, and most mainstream languages. Quality varies with training data volume — the top ten languages are noticeably stronger than the long tail.

Is there an open-weight Codestral?

Yes — Codestral Mamba has been released under a permissive licence. Hosted Codestral on La Plateforme is faster and receives the current tuning; the open weights let you self-host the completion path end-to-end.

Can I fine-tune Codestral?

Fine-tuning is supported on La Plateforme for Codestral, though most teams find that a good retrieval layer over their internal code — feeding relevant snippets in as context — closes the same gap without the training cost. Try retrieval first, fine-tune only if evaluations show the domain vocabulary genuinely needs to be baked into the weights.

What is the context window of Codestral?

Codestral ships with a long context window (32k+ tokens) which is plenty for a single file plus a couple of imports. For repository-scale reasoning you still need a retrieval layer to pick the right passages — no current model handles a full 100k-file monorepo as raw context, and stuffing more tokens in rarely improves single-file completion quality.

How does Codestral handle proprietary internal code?

The hosted API sees only what you send; nothing about your codebase is retained for training. If your policy forbids source code leaving your infrastructure at all, the open-weight Codestral Mamba release lets you self-host the completion path. Both paths keep your intellectual property out of shared model training pipelines.

Is there a free tier for evaluation?

Yes — La Plateforme's free tier covers Codestral for evaluation traffic, subject to per-day and per-model rate limits documented in the console. That is enough to run a serious two-week team bake-in against Copilot or another baseline before you commit any budget. Move to paid when your evaluation clearly shows the quality and latency both hold up on real editor traffic, not just on a scripted benchmark.

Codestral for developers: what it's good at (and what it isn't)

What Codestral is

Codestral is Mistral's code-first model: trained on 80+ programming languages with a fill-in-the-middle (FIM) objective. That FIM training is why it is strong at IDE-style autocomplete where the model must generate code that fits between a prefix and a suffix rather than continuing from the end. It ships as a general chat model too, but the FIM endpoint is where the specialization actually earns its keep.

Where Codestral shines

IDE completions and multi-line suggestions triggered by cursor position.
Small, well-scoped refactors ('convert this function to async', 'add error handling', 'extract this block into a helper').
Language-to-language translation (Python → TypeScript, SQL dialect swaps, Ruby → Go).
Docstring and comment generation from existing code.
Boilerplate scaffolding — API clients from an OpenAPI spec, test skeletons from a signature.

Where Codestral struggles

Long-horizon agentic tasks with tool use — reach for Mistral Large instead.
Reasoning-heavy debugging where the fix requires understanding a whole system, not just a local edit.
Producing prose-heavy technical explanations — a general model handles voice better.
Multi-file refactors that need to hold a project mental model — Codestral has no persistent workspace context.

The FIM endpoint

Codestral exposes the standard chat/completions surface plus a dedicated `/v1/fim/completions` endpoint for prefix + suffix inputs. Editors integrating IDE autocomplete should target the FIM endpoint — it produces tighter, less chatty output than a chat prompt asking for the same thing, because the model was trained specifically for that shape. Send the code before the cursor as prefix and the code after as suffix; Codestral fills the gap.

Codestral in your editor

Continue.dev, Cursor, Tabby, and llama.cpp-based editors all support Codestral as a backend. Point them at Mistral's endpoint with your API key, or self-host the open-weight Codestral Mamba release for airtight data isolation. Latency is what makes autocomplete feel usable; check that your provider's TTFT is under 200ms on your network before you commit to a backend.

Prompting Codestral for chat-style code tasks

Even without the FIM endpoint, Codestral responds well to prompts that are unambiguously code tasks: 'Rewrite this function to use async/await. Return only the code, no explanation.' The 'return only the code' hint matters — Codestral is more likely than a general model to volunteer a preamble.

Codestral vs Mistral Large for code

For a self-contained task that fits in a single file — a function, a refactor, a translation — Codestral is faster and often better than Large because that is exactly what it was trained on. For code embedded in a multi-step plan (analyze the failure, decide which file to change, produce a patch, write the test), Large's reasoning gap wins. A common pattern: Large plans, Codestral drafts, Large reviews.

Open-weight Codestral

Mistral has released Codestral Mamba under a permissive licence, so self-hosting is a genuine option for teams with data-residency or offline requirements. The hosted API is faster and gets the current tuning; the open weights let you keep the entire completion path on your own hardware. Benchmarks are close on standard code eval sets.

Latency budgets for autocomplete

IDE autocomplete lives and dies on time-to-first-token. Under 100ms feels instant; 200–400ms feels helpful; over 500ms feels like you're waiting on a server and users start typing over the suggestion. Measure TTFT end-to-end from keystroke to first suggested character, not just from HTTP send. Network hop, tokenizer time, and your editor's debounce all count. Codestral hosted on La Plateforme routinely lands under 200ms in EU regions; adding a hop through your own proxy is often what breaks that budget.

Security review of AI-completed code

Every completion Codestral emits should be treated as untrusted input from an external contributor. That means the same static analysis, dependency policy, and secrets scan that runs on human commits also runs on merged AI output. In practice this is easier than teams expect — pre-commit hooks, CodeQL, Semgrep, and your existing PR review process cover it. The failure mode to guard against is completions that hardcode credentials copied from training data; secrets-scanning CI catches these before merge.

Codestral vs GitHub Copilot in practice

Copilot's headline advantage is IDE polish; Codestral's is data locality and open weights. If your compliance story requires that no source code leaves your infrastructure, self-hosted Codestral Mamba is a viable path where Copilot is not. On raw completion quality the gap is small enough that team preference and IDE integration usually decide it — run a two-week bake-in with real engineers on both backends before you commit either way.

Editor and IDE integration, step by step

In VS Code, install the Continue.dev extension, open its config, and add a model block: `{ title: 'Codestral', provider: 'mistral', model: 'codestral-latest', apiKey: '<key>' }` for chat, plus a `tabAutocompleteModel` block pointing at the same model for inline completions. Cursor supports Mistral via custom models — paste your key in Settings → Models → Add Custom Model, base URL `https://api.mistral.ai/v1`, model id `codestral-latest`. JetBrains editors reach Codestral via Continue.jetbrains or the Tabby plugin. For Vim/Neovim, Tabby's LSP works cleanly. In every case, the two knobs that matter most after keys are (a) debounce — 100–200ms hides latency without feeling laggy — and (b) suggestion max length: cap at 50–80 tokens for inline completion so you are not paying for a paragraph the user will overwrite with the next keystroke.

Fill-in-the-middle in practice

The FIM request is dead simple: POST to `/v1/fim/completions` with `{ model: 'codestral-latest', prompt: '<code before cursor>', suffix: '<code after cursor>', max_tokens: 64 }`. Concrete example — user cursor is inside a half-written function: prompt = `function sumEven(nums: number[]) {\n return nums.filter(`, suffix = `).reduce((a, b) => a + b, 0);\n}`. Codestral returns `n => n % 2 === 0` and your editor inserts it exactly where the cursor sits. Compare to a chat-style prompt ('complete this function') which will happily return a full re-write plus explanation and requires post-processing to extract just the middle. FIM is why editor integrations feel tight; skipping it for a chat prompt is the number-one reason a Codestral setup feels laggy or chatty in an IDE.

Codestral vs GitHub Copilot: a fair side-by-side

On raw single-file completion quality across TypeScript, Python, and Go, blind grading of a 200-completion sample usually shows the two within a few percentage points. Copilot has the edge on niche language ergonomics (Swift, Kotlin, Objective-C) because of GitHub's training data breadth; Codestral has the edge on European languages in comments/docstrings and on staying terse when asked. Latency is a wash if both are hitting their nearest region. The real differentiators are non-technical: Copilot's IDE polish and JetBrains integration are more mature, while Codestral offers a legitimate self-hosting path (open-weight Codestral Mamba) and EU-default data residency. Enterprises with a strict 'no source code leaves our VPC' policy end up on Codestral because Copilot cannot meet that bar today; teams that prioritize plug-and-play IDE UX often stay on Copilot. Run both for two weeks with real engineers before committing.