Skip to main content
Glama

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

vibe_run

Start a new Vibe session with a prompt in a project directory.

vibe_resume

Continue the last session (--continue) or resume a specific one (--resume SESSION_ID).

vibe_manage

status (installed? version), install, or update Vibe via uv.

vibe_run

Field

Type

Notes

prompt

string (required)

Instruction for the agent.

project_dir

string

Working dir. Defaults to the server cwd.

max_turns

integer

--max-turns (recommended).

max_tokens

integer

--max-tokens.

max_price

number

--max-price (indicative, not a hard budget).

time_limit

integer

--time-limit (seconds).

model

string

--model alias.

agent

enum

ask | accept-edits | smart-approve | auto-approve.

enabled_tools

string[]

--enabled-tools (repeatable; globs / re: regex).

disabled_tools

string[]

--disabled-tools (repeatable).

auto_approve

boolean

--auto-approve/--yolo. Default false.

worktree

string|boolean

--worktree [name].

trust

boolean

--trust (temporary trust for cwd).

output

enum

json (default) | text | streaming.

vibe_resume

Same fields as vibe_run (prompt optional), plus:

Field

Type

Notes

session_id

string

Resume a specific session (--resume). Partial ids are accepted by Vibe.

continue

boolean

Continue the last session for the dir (--continue). Default when no session_id.

If both session_id and continue are given, session_id wins and a note is returned.

vibe_manage

Field

Type

Notes

action

enum (required)

status | install | update. install/update run uv tool install --upgrade mistral-vibe.

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 run vibe_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 build

The 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 if vibe isn'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 test runs the unit tests (no Vibe binary or network needed).

  • npm run build typechecks and emits dist/.

  • npm run dev runs 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-run

Skills live under skills/<name>/SKILL.md (the standard npx skills discovery path):

Skill

Teaches

mistral-vibe

Umbrella overview + when to load the others.

vibe-run

Starting a new session: prompt, project_dir, guardrails, agent profiles, auto_approve caution.

vibe-resume

Resume (session_id) vs continue precedence and when to use each.

vibe-manage

status/install/update via uv, and VIBE_BIN.

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 tools
vibe_manageA

Operational helper for the Vibe CLI: status (installed? version), install, or update via uv tool install --upgrade mistral-vibe.

NameRequiredDescriptionDefault
actionYesstatus: check install/version; install/update: run uv tool install --upgrade.

TDQS

A3.7/5.0
Behavior4/5

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.

Conciseness4/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.

NameRequiredDescriptionDefault
agentNoApproval profile (--agent).
modelNoModel alias (--model).
trustNoTemporarily trust cwd (--trust).
outputNoVibe output format. Default json.
promptNoOptional follow-up instruction.
continueNoContinue the last session (--continue). Default when no session_id.
worktreeNoRun in a git worktree (--worktree [name]).
max_priceNoIndicative budget in dollars (--max-price; not a hard limit).
max_turnsNoCap agent turns (--max-turns).
max_tokensNoCap tokens (--max-tokens).
session_idNoResume a specific session (--resume). Partial ids accepted.
time_limitNoWall-clock seconds (--time-limit).
project_dirNoDirectory the agent runs in. Defaults to the server's cwd.
auto_approveNoApprove every tool call (--auto-approve/--yolo). Default false.
enabled_toolsNoAllow-list tools (--enabled-tools, repeatable; globs/re:).
disabled_toolsNoDeny-list tools (--disabled-tools, repeatable).

TDQS

A3.5/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines4/5

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.

NameRequiredDescriptionDefault
agentNoApproval profile (--agent).
modelNoModel alias (--model).
trustNoTemporarily trust cwd (--trust).
outputNoVibe output format. Default json.
promptYesThe instruction for the Vibe agent.
worktreeNoRun in a git worktree (--worktree [name]).
max_priceNoIndicative budget in dollars (--max-price; not a hard limit).
max_turnsNoCap agent turns (--max-turns).
max_tokensNoCap tokens (--max-tokens).
time_limitNoWall-clock seconds (--time-limit).
project_dirNoDirectory the agent runs in. Defaults to the server's cwd.
auto_approveNoApprove every tool call (--auto-approve/--yolo). Default false.
enabled_toolsNoAllow-list tools (--enabled-tools, repeatable; globs/re:).
disabled_toolsNoDeny-list tools (--disabled-tools, repeatable).

TDQS

B3.2/5.0
Behavior2/5

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.

Conciseness4/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.

  1. 3 tool updatesv0.1.0
    • First observedvibe_manage
    • First observedvibe_resume
    • First observedvibe_run

TDQS

A3.7/5.0

Scored across 3 tools

Disambiguation5/5

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.

Naming Consistency5/5

All three tools use a consistent vibe_<verb> snake_case pattern (vibe_run, vibe_resume, vibe_manage). Names are short, readable, and predictable.

Tool Count4/5

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.

Completeness4/5

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

ActivityMaintained
ResponsivenessSyncing

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    Enables MCP clients to spawn and control Codex CLI and Claude Code sessions on the host machine, with session management and filesystem access.
    4
    MIT
  • A
    license
    B
    quality
    B
    maintenance
    Enables 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.
    2
    336 npm
    1
    MIT
  • A
    license
    Not graded
    quality
    A
    maintenance
    Enables 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 npm
    MIT