mistral-vibe-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mistral-vibe-mcpStart a Vibe session to add tests for the login form"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
mistral-vibe-mcp
An MCP stdio server that wraps the
Mistral Vibe CLI (vibe /
mistral-vibe) so any MCP client — Claude Desktop, Codex, Cursor, etc. — can drive the
Vibe coding agent programmatically.
This is a clean-room implementation under the MIT license. It is inspired by the idea
of an earlier vibe-mcp project but shares no code with it.
Tools
Tool | Purpose |
| Start a new Vibe session with a prompt in a project directory. |
| Continue the last session ( |
|
|
vibe_run
Field | Type | Notes |
| string (required) | Instruction for the agent. |
| string | Working dir. Defaults to the server cwd. |
| integer |
|
| integer |
|
| number |
|
| integer |
|
| string |
|
| enum |
|
| string[] |
|
| string[] |
|
| boolean |
|
| string|boolean |
|
| boolean |
|
| enum |
|
vibe_resume
Same fields as vibe_run (prompt optional), plus:
Field | Type | Notes |
| string | Resume a specific session ( |
| boolean | Continue the last session for the dir ( |
If both session_id and continue are given, session_id wins and a note is returned.
vibe_manage
Field | Type | Notes |
| enum (required) |
|
Result shape
Each vibe_run / vibe_resume call returns a human summary line plus a JSON block:
{
"ok": true,
"exitCode": 0,
"exitClass": "finished",
"sessionId": "abc123",
"summary": { "cost": 0.012, "turns": 3, "tokens": 2048 },
"output": { "...": "parsed vibe --output json, or null" },
"stderr": "..."
}exitClass maps Vibe's documented exit codes: 0 finished, 1 start-or-config-error,
2 api-or-runtime-error, 3 stopped-early.
Related MCP server: cursor-agent-bridge
Prerequisites
Node 20+
Mistral Vibe CLI installed:
uv tool install --upgrade mistral-vibe(Need
uv? See the uv install guide.) You can also runvibe_manage { "action": "install" }from any MCP client.
If the vibe binary lives somewhere non-standard, set VIBE_BIN to its path.
Install & build
git clone https://github.com/sohampatwardhan/mistral-vibe-mcp.git
cd mistral-vibe-mcp
npm install
npm run buildThe server entrypoint is dist/index.js (also exposed as the mistral-vibe-mcp bin).
MCP client configuration
All clients launch the server over stdio with node /abs/path/to/dist/index.js.
Claude Desktop
claude_desktop_config.json:
{
"mcpServers": {
"mistral-vibe": {
"command": "node",
"args": ["/abs/path/to/mistral-vibe-mcp/dist/index.js"]
}
}
}Codex
~/.codex/config.toml:
[mcp_servers.mistral-vibe]
command = "node"
args = ["/abs/path/to/mistral-vibe-mcp/dist/index.js"]Cursor
.cursor/mcp.json (project) or ~/.cursor/mcp.json (global):
{
"mcpServers": {
"mistral-vibe": {
"command": "node",
"args": ["/abs/path/to/mistral-vibe-mcp/dist/index.js"]
}
}
}Optional env: add
"env": { "VIBE_BIN": "/path/to/vibe" }to any of the above ifvibeisn't on PATH for the client process.
Example calls
// vibe_run
{ "prompt": "Add input validation to the login form", "max_turns": 6, "agent": "accept-edits" }
// vibe_resume - specific session
{ "session_id": "abc123", "prompt": "now add tests" }
// vibe_resume - continue last
{ "continue": true, "prompt": "keep going" }
// vibe_manage
{ "action": "status" }Development
npm testruns the unit tests (no Vibe binary or network needed).npm run buildtypechecks and emitsdist/.npm run devruns the compiler in watch mode.
Tests cover the pure core (CLI argument building, output parsing, session-id extraction).
Process spawning is isolated in src/runner.ts so the rest of the code stays testable.
How it works
MCP client <-> (stdio/JSON-RPC) <-> index.ts
|- tools.ts (schemas + dispatch)
|- args.ts (pure argv builders)
|- parse.ts (pure output parsing)
|- runner.ts (spawn vibe)
|- manage.ts (status/install/update)The server never builds shell strings; it spawns vibe with an argv array, so prompts and
tool names can't inject shell commands.
Agent Skills
This repo ships Agent Skills so an agent can learn how
to drive these MCP tools. Install them with the skills CLI:
# all skills in this repo
npx skills add sohampatwardhan/mistral-vibe-mcp
# a specific skill
npx skills add sohampatwardhan/mistral-vibe-mcp --skill vibe-runSkills live under skills/<name>/SKILL.md (the standard npx skills discovery path):
Skill | Teaches |
| Umbrella overview + when to load the others. |
| Starting a new session: prompt, |
| Resume ( |
|
|
These skills teach how to use this server's tools; they are not a copy of Vibe's own docs.
License
MIT - see LICENSE.
Session and flag behavior is based on the current Vibe CLI programmatic docs: https://docs.mistral.ai/vibe/code/cli/work-with-cli.
Available Tools
3 toolsvibe_manageA
Operational helper for the Vibe CLI: status (installed? version), install, or update via uv tool install --upgrade mistral-vibe.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | status: check install/version; install/update: run uv tool install --upgrade. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations supplied, the description carries the full burden, and it does disclose the exact underlying command (`uv tool install --upgrade mistral-vibe`), which reveals the real side effect of install/update. It stops short of describing permission, network, or failure behavior (e.g., what happens if the tool is already current), so it is informative but not exhaustive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One compact sentence that front-loads the resource ('Operational helper for the Vibe CLI') and then lists the actions with the command quoted inline. Nothing is wasted, though the parenthetical/nesting makes it slightly denser than a plain action list.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter tool with no nested objects and no output schema, the description covers purpose, the three modes, and the implementation command, which is enough to call it correctly. The remaining gap is the return shape of `status` and of install/update, which is only gestured at with '(installed? version)'.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single `action` parameter is fully documented in the schema, including enum values and their meaning, so the baseline is 3. The description's parenthetical '(installed? version)' adds a small hint about what the status action reports, but otherwise restates the schema's enum descriptions almost verbatim.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a concrete resource (the Vibe CLI installation) and enumerates the three operations it supports: status, install, and update. That is specific enough to separate it from vibe_run and vibe_resume, which operate on sessions rather than the CLI install, though the description never explicitly states that distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: an agent can infer 'use this when you need to check or change whether the Vibe CLI is installed', but the description never says when to prefer this over the sibling tools or what prerequisite conditions apply (e.g., whether uv must already be present).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vibe_resumeA
Continue a previous Vibe session. Provide session_id to resume a specific session (--resume), or continue:true (default when no session_id) to continue the last session for the directory.
| Name | Required | Description | Default |
|---|---|---|---|
| agent | No | Approval profile (--agent). | |
| model | No | Model alias (--model). | |
| trust | No | Temporarily trust cwd (--trust). | |
| output | No | Vibe output format. Default json. | |
| prompt | No | Optional follow-up instruction. | |
| continue | No | Continue the last session (--continue). Default when no session_id. | |
| worktree | No | Run in a git worktree (--worktree [name]). | |
| max_price | No | Indicative budget in dollars (--max-price; not a hard limit). | |
| max_turns | No | Cap agent turns (--max-turns). | |
| max_tokens | No | Cap tokens (--max-tokens). | |
| session_id | No | Resume a specific session (--resume). Partial ids accepted. | |
| time_limit | No | Wall-clock seconds (--time-limit). | |
| project_dir | No | Directory the agent runs in. Defaults to the server's cwd. | |
| auto_approve | No | Approve every tool call (--auto-approve/--yolo). Default false. | |
| enabled_tools | No | Allow-list tools (--enabled-tools, repeatable; globs/re:). | |
| disabled_tools | No | Deny-list tools (--disabled-tools, repeatable). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden, but it only explains the session-selection logic. It does not describe what continuing a session actually does, whether it executes tools or mutates files, how approval/trust settings affect behavior, or what the agent should expect from the many execution-related parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core action and followed by the session-selection rule. There is no unnecessary wording or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 16-parameter tool with no annotations and no output schema, the description covers the essential resume-versus-continue routing. However, it leaves out behavioral context around execution, approvals, worktrees, and side effects, so it is minimally adequate rather than complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 16 parameters. The description mainly restates session_id and continue behavior already present in the schema and adds no additional meaning for parameters such as agent, trust, worktree, max_price, or auto_approve.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Continue a previous Vibe session.' It is clear enough to distinguish resuming from starting a new run, but it does not explicitly name or contrast with the sibling tools vibe_run or vibe_manage.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives clear usage guidance for the key choice: provide session_id to resume a specific session, or use continue:true (the default without session_id) to continue the last session for the directory. It does not state when not to use this tool or explicitly route to sibling alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vibe_runB
Start a new Mistral Vibe coding-agent session with a prompt in a project directory. Returns parsed JSON output, session id, exit classification, and a cost/turn summary when available.
| Name | Required | Description | Default |
|---|---|---|---|
| agent | No | Approval profile (--agent). | |
| model | No | Model alias (--model). | |
| trust | No | Temporarily trust cwd (--trust). | |
| output | No | Vibe output format. Default json. | |
| prompt | Yes | The instruction for the Vibe agent. | |
| worktree | No | Run in a git worktree (--worktree [name]). | |
| max_price | No | Indicative budget in dollars (--max-price; not a hard limit). | |
| max_turns | No | Cap agent turns (--max-turns). | |
| max_tokens | No | Cap tokens (--max-tokens). | |
| time_limit | No | Wall-clock seconds (--time-limit). | |
| project_dir | No | Directory the agent runs in. Defaults to the server's cwd. | |
| auto_approve | No | Approve every tool call (--auto-approve/--yolo). Default false. | |
| enabled_tools | No | Allow-list tools (--enabled-tools, repeatable; globs/re:). | |
| disabled_tools | No | Deny-list tools (--disabled-tools, repeatable). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the return payload (parsed JSON, session id, exit classification, cost/turn summary), which is useful, but it never states that this launches an autonomous agent that can read and modify files in the project directory, that it is long-running, or what approval semantics apply by default.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences, front-loaded with the action and resource, then the return shape. No filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 14-parameter tool with no annotations and no output schema, the description covers purpose and return values but omits side effects, default approval behavior (auto_approve defaults false, agent profiles), and lifecycle concerns like time limits. An agent could call it without knowing it may mutate the working tree.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and each parameter is documented inline with its CLI flag, so the description adds nothing beyond the schema. Baseline 3 applies; the description mentions only prompt and project directory, both already covered.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb and resource: 'Start a new Mistral Vibe coding-agent session,' plus the required prompt and project directory. It distinguishes itself from vibe_resume only implicitly via 'new,' rather than naming the sibling or its boundary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Start a new ... session' implies this is for beginning rather than continuing work, which hints at when to use it versus vibe_resume, but there is no explicit when/when-not guidance, no mention of prerequisites (git repo, auth, trust), and no routing to vibe_manage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v0.1.0- First observed
vibe_manage - First observed
vibe_resume - First observed
vibe_run
TDQS
Scored across 3 tools
Each tool targets a distinct lifecycle phase: starting a session (vibe_run), continuing one (vibe_resume), and CLI maintenance (vibe_manage). There is no overlap — run vs resume is clearly separated by whether a new prompt/session or an existing session is involved.
All three tools use a consistent vibe_<verb> snake_case pattern (vibe_run, vibe_resume, vibe_manage). Names are short, readable, and predictable.
Three tools is on the thin side but well-matched to a focused CLI wrapper: launch, continue, maintain. Nothing extraneous, though a couple more operations could reasonably be added.
The core agent-session lifecycle (start, resume, install/update/status) is covered, which handles the main workflows. Minor gaps exist — no session listing, cancellation/kill of a running session, or history retrieval — but agents can work around these via run/resume output.
Maintenance
Related MCP Connectors
Start and manage Reason cloud coding agents, projects and sessions from any MCP client.
Open-source vibe coding hosting over MCP: your agent builds, previews and publishes web apps.
Project management shared by people and AI agents, with persistent project state through MCP.
Hosted MCP server and Agent Skills for specs, engineering threads, and project memory.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables MCP clients to spawn and control Codex CLI and Claude Code sessions on the host machine, with session management and filesystem access.4MIT
- AlicenseNot gradedqualityBmaintenanceEnables MCP clients like Claude Code to delegate coding tasks to the local Cursor Agent CLI, with persistent per-workspace sessions that resume across calls.12 npmMIT
- AlicenseBqualityBmaintenanceEnables launching and supervising local Codex and Claude Code agent sessions and one-shot tasks, exposing run, list, stop, and output operations over MCP with session-scoped permissions and sandbox controls.2336 npm1MIT
- AlicenseNot gradedqualityAmaintenanceEnables any MCP-compatible client to run reusable, Markdown-defined coding agents (such as reviewers, test writers, or investigators) through a configurable coding CLI backend, returning results into the same conversation. Agent definitions and backend/model settings can be shared across clients, and sessions can persist across multiple calls for longer work.315 npmMIT