Oversee AI Agents with Meta-Mentorship

Vibe Check MCP

This project is in maintenance mode. Active feature development has ended; only maintenance patches (security and bug fixes) are published. v2.9.0 is the latest maintenance release. The server remains fully functional. Community forks and contributions are welcome under the MIT license.

Plug-and-play mentor layer that stops agents from over-engineering and keeps them on the minimal viable path - research-backed MCP server keeping LLMs aligned, reflective and safe.

Quickstart (npx)

Run the server directly from npm without a local installation. Requires Node >=20. Choose a transport:

Option 1 - MCP client over STDIO

npx -y @pv-bhat/vibe-check-mcp start --stdio

• Launch from an MCP-aware client (Claude Desktop, Cursor, Windsurf, etc.).
• [MCP] stdio transport connected indicates the process is waiting for the client.
• Add this block to your client config so it spawns the command:

{
  "mcpServers": {
    "vibe-check-mcp": {
      "command": "npx",
      "args": ["-y", "@pv-bhat/vibe-check-mcp", "start", "--stdio"]
    }
  }
}

Option 2 - Manual HTTP inspection

npx -y @pv-bhat/vibe-check-mcp start --http --port 2091

• curl http://127.0.0.1:2091/healthz to confirm the service is live.
• Send JSON-RPC requests to http://127.0.0.1:2091/mcp.

npx downloads the package on demand for both options. For detailed client setup and other commands like install and doctor, see the documentation below.

Recognition

• Featured on PulseMCP “Most Popular (This Week)” front page (week of 13 Oct 2025) 🔗
• Listed in Anthropic’s official Model Context Protocol repo 🔗
• Discoverable in the official MCP Registry 🔗
• Featured on Sean Kochel's Top 9 MCP servers for vibe coders 🔗

Table of Contents

• Quickstart (npx)
• What is Vibe Check MCP?
• Overview
• The Problem: Pattern Inertia & Reasoning Lock-In
• Key Features
• What's New
• Development Setup
• Release
• Usage Examples
• Adaptive Metacognitive Interrupts (CPI)
• Agent Prompting Essentials
• When to Use Each Tool
• Documentation
• Research & Philosophy
• Security
• Roadmap
• Contributors & Community
• FAQ
• Listed on
• Credits & License

What is Vibe Check MCP?

Vibe Check MCP keeps agents on the minimal viable path and escalates complexity only when evidence demands it. Vibe Check MCP is a lightweight server implementing Anthropic's Model Context Protocol. It acts as an AI meta-mentor for your agents, interrupting pattern inertia with Chain-Pattern Interrupts (CPI) to prevent Reasoning Lock-In (RLI). Think of it as a rubber-duck debugger for LLMs - a quick sanity check before your agent goes down the wrong path.

Overview

Vibe Check MCP pairs a metacognitive signal layer with CPI so agents can pause when risk spikes. Vibe Check surfaces traits, uncertainty, and risk scores; CPI consumes those triggers and enforces an intervention policy before the agent resumes. See the CPI integration guide and the CPI repo at https://github.com/PV-Bhat/cpi for wiring details.

Vibe Check invokes a second LLM to give meta-cognitive feedback to your main agent. Integrating vibe_check calls into agent system prompts and instructing tool calls before irreversible actions significantly improves agent alignment and common-sense. The high-level component map: docs/architecture.md, while the CPI handoff diagram and example shim are captured in docs/integrations/cpi.md.

The Problem: Pattern Inertia & Reasoning Lock-In

Large language models can confidently follow flawed plans. Without an external nudge they may spiral into overengineering or misalignment. Vibe Check provides that nudge through short reflective pauses, improving reliability and safety.

Key Features

What's New in v2.9.0 (Security & Model Refresh)

Maintenance Notice: This project is in maintenance mode and is no longer under active feature development. It remains fully functional and available under the MIT license. Community forks are welcome. For details, see the Changelog.

• Current models: Gemini 3.6 Flash, Claude Sonnet 5 / Opus 5 / Fable 5, and GPT-5.6 Sol / Terra / Luna are now the supported defaults, defined in one registry (src/utils/models.ts)
• Native Google AI Studio: migrated from the retired @google/generative-ai package to the unified @google/genai SDK
• HTTP hardening: CORS now defaults to loopback origins instead of *, Host headers are validated to block DNS rebinding, and the JSON body cap is explicit and validated
• Security: npm audit is clean - 10 advisories resolved across axios, the MCP SDK's Hono stack, form-data, fast-uri, postcss and the test toolchain
• Dependencies: MCP SDK 1.29, axios 1.18, OpenAI SDK 6.x, vitest 4.x; the unused body-parser direct dependency was dropped

Session Constitution (per-session rules)

Use a lightweight “constitution” to enforce rules per sessionId that CPI will honor. Eg. constitution rules: “no external network calls,” “prefer unit tests before refactors,” “never write secrets to disk.”

API (tools):

• update_constitution({ sessionId, rules }) → merges/sets rule set for the session
• reset_constitution({ sessionId }) → clears session rules
• check_constitution({ sessionId }) → returns effective rules for the session

Development Setup

# Clone and install
git clone https://github.com/PV-Bhat/vibe-check-mcp-server.git
cd vibe-check-mcp-server
npm ci
npm run build
npm test

Use npm for all workflows (npm ci, npm run build, npm test). This project targets Node >=20.

Create a .env file with the API keys you plan to use:

# Gemini (default)
GEMINI_API_KEY=your_gemini_api_key
# Optional providers / Anthropic-compatible endpoints
OPENAI_API_KEY=your_openai_api_key
OPENROUTER_API_KEY=your_openrouter_api_key
ANTHROPIC_API_KEY=your_anthropic_api_key
ANTHROPIC_AUTH_TOKEN=your_proxy_bearer_token
ANTHROPIC_BASE_URL=https://api.anthropic.com
ANTHROPIC_VERSION=2023-06-01
# Optional overrides
# DEFAULT_LLM_PROVIDER accepts gemini | openai | openrouter | anthropic
DEFAULT_LLM_PROVIDER=gemini
# Leave DEFAULT_MODEL unset to use each provider's default (see table below)
# DEFAULT_MODEL=gemini-3.6-flash

Providers and models

Gemini runs natively against Google AI Studio (the Gemini Developer API) through the unified @google/genai SDK. Any model ID the provider accepts will work - the table lists the defaults and the suggestions surfaced to agents in the vibe_check tool schema.

Set the default globally with DEFAULT_LLM_PROVIDER / DEFAULT_MODEL, or per call with modelOverride. DEFAULT_MODEL names a model of DEFAULT_LLM_PROVIDER; a call that overrides the provider without naming a model falls through to that provider's default rather than reusing it.

{ "goal": "...", "plan": "...", "modelOverride": { "provider": "anthropic", "model": "claude-opus-5" } }

If a Gemini call fails, the server retries once against gemini-3.5-flash-lite before falling back to static questions.

HTTP transport hardening

These apply only to --http mode; stdio is unaffected.

Upgrading to v2.9.0 over HTTP: if you serve Vibe Check on a non-loopback hostname (Docker, a reverse proxy, a hosted deployment), set MCP_ALLOWED_HOSTS to that hostname - or * - or requests will be rejected with HTTP 403.

Configuration

See docs/TESTING.md for instructions on how to run tests.

Docker

The repository includes a helper script for one-command setup.

bash scripts/docker-setup.sh

See Automatic Docker Setup for full details.

Provider keys

See API Keys & Secret Management for supported providers, resolution order, storage locations, and security guidance.

Transport selection

The CLI supports stdio and HTTP transports. Transport resolution follows this order: explicit flags (--stdio/--http) → MCP_TRANSPORT → default stdio. When using HTTP, specify --port (or set MCP_HTTP_PORT); the default port is 2091. The generated entries add --stdio or --http --port <n> accordingly, and HTTP-capable clients also receive a http://127.0.0.1:<port> endpoint.

Client installers

Each installer is idempotent and tags entries with "managedBy": "vibe-check-mcp-cli". Backups are written once per run before changes are applied, and merges are atomic (*.bak files make rollback easy). See docs/clients.md for deeper client-specific references.

Claude Desktop

• Config path: claude_desktop_config.json (auto-discovered per platform).
• Default transport: stdio (npx … start --stdio).
• Restart Claude Desktop after installation to load the new MCP server.
• If an unmanaged entry already exists for vibe-check-mcp, the CLI leaves it untouched and prints a warning.

Cursor

• Config path: ~/.cursor/mcp.json (provide --config if you store it elsewhere).
• Schema mirrors Claude’s mcpServers layout.
• If the file is missing, the CLI prints a ready-to-paste JSON block for Cursor’s settings panel instead of failing.

Windsurf (Cascade)

• Config path: legacy ~/.codeium/windsurf/mcp_config.json, new builds use ~/.codeium/mcp_config.json.
• Pass --http to emit an entry with serverUrl for Windsurf’s HTTP client.
• Existing sentinel-managed serverUrl entries are preserved and updated in place.

Visual Studio Code

• Workspace config lives at .vscode/mcp.json; profiles also store mcp.json in your VS Code user data directory.
• Provide --config <path> to target a workspace file. Without --config, the CLI prints a JSON snippet and a vscode:mcp/install?... link you can open directly from the terminal.
• VS Code supports optional dev fields; pass --dev-watch and/or --dev-debug <value> to populate dev.watch/dev.debug.

Uninstall & rollback

• Restore the backup generated during installation (the newest *.bak next to your config) to revert immediately.
• To remove the server manually, delete the vibe-check-mcp entry under mcpServers (Claude/Windsurf/Cursor) or servers (VS Code) as long as it is still tagged with "managedBy": "vibe-check-mcp-cli".

Research & Philosophy

CPI (Chain-Pattern Interrupt) is the research-backed oversight method behind Vibe Check. It injects brief, well-timed “pause points” at risk inflection moments to re-align the agent to the user’s true priority, preventing destructive cascades and reasoning lock-in (RLI). In pooled evaluation across 153 runs, CPI nearly doubles success (27%→54%) and roughly halves harmful actions (83%→42%). Optimal interrupt dosage is ~10-20% of steps. Vibe Check MCP implements CPI as an external mentor layer at test time.

Links:

• 📄 CPI Paper (ResearchGate) - http://dx.doi.org/10.13140/RG.2.2.18237.93922
• 📘 CPI Reference Implementation (GitHub): https://github.com/PV-Bhat/cpi
• 📚 MURST Zenodo DOI (RSRC archival): https://doi.org/10.5281/zenodo.14851363

flowchart TD
  A[Agent Phase] --> B{Monitor Progress}
  B -- high risk --> C[CPI Interrupt]
  C --> D[Reflect & Adjust]
  B -- smooth --> E[Continue]

Agent Prompting Essentials

In your agent's system prompt, make it clear that vibe_check is a mandatory tool for reflection. Always pass the full user request and other relevant context. After correcting a mistake, you can optionally log it with vibe_learn to build a history for future analysis.

Example snippet:

As an autonomous agent you will:
1. Call vibe_check after planning and before major actions.
2. Provide the full user request and your current plan.
3. Optionally, record resolved issues with vibe_learn.

When to Use Each Tool

Documentation

• Agent Prompting Strategies
• CPI Integration
• Advanced Integration
• Technical Reference
• Automatic Docker Setup
• Philosophy
• Case Studies
• Changelog

Security

This repository includes a CI-based security scan that runs on every pull request. It checks dependencies with npm audit and scans the source for risky patterns. See SECURITY.md for details and how to report issues.

Roadmap

Note: This project is in maintenance mode (latest maintenance release: v2.9.0). The roadmap below is preserved for community forks that may wish to continue development.

• Structured output for vibe_check: Return a JSON envelope such as { advice, riskScore, traits } so downstream agents can reason deterministically.
• LLM resilience: Wrap generateResponse with retries and exponential backoff.
• Input sanitization: Validate and cleanse tool arguments to mitigate prompt-injection vectors.
• Prompt externalization: Move hardcoded prompts to configuration files for transparency and auditability (see PR #71).

Links

• MSEEP
• MCP Servers
• MCP.so
• Creati.ai
• Pulse MCP
• Playbooks.com
• MCPHub.tools
• MCP Directory

Author Credits & Links

Vibe Check MCP created by: Pruthvi Bhat, Initiative - https://murst.org/

scripts/docker-setup.sh

#!/bin/bash

echo "========================================================"
echo "Vibe Check MCP Docker Setup for Cursor IDE"
echo "========================================================"
echo ""

# Check for Docker installation
if ! command -v docker &> /dev/null; then
    echo "Error: Docker is not installed or not in PATH."
    echo "Please install Docker from https://docs.docker.com/get-docker/"
    exit 1
fi

# Check for Docker Compose installation
if ! command -v docker-compose &> /dev/null; then
    echo "Error: Docker Compose is not installed or not in PATH."
    echo "Please install Docker Compose from https://docs.docker.com/compose/install/"
    exit 1
fi

# Create directory for Vibe Check MCP
mkdir -p ~/vibe-check-mcp
cd ~/vibe-check-mcp

# Download or create necessary files
echo "Downloading required files..."

# Create docker-compose.yml
cat > docker-compose.yml << 'EOL'
version: '3'

services:
  vibe-check-mcp:
    build:
      context: .
      dockerfile: Dockerfile
    image: vibe-check-mcp:latest
    container_name: vibe-check-mcp
    restart: always
    environment:
      - GEMINI_API_KEY=${GEMINI_API_KEY}
      # Other containers reach this service by its compose name, so that
      # hostname has to be allowed alongside the loopback defaults.
      - MCP_ALLOWED_HOSTS=${MCP_ALLOWED_HOSTS:-vibe-check-mcp,localhost,127.0.0.1,::1}
    volumes:
      - vibe-check-data:/app/data

volumes:
  vibe-check-data:
EOL

# Create Dockerfile if it doesn't exist
cat > Dockerfile << 'EOL'
FROM node:lts-alpine

WORKDIR /app

# Clone the repository
RUN apk add --no-cache git \
    && git clone https://github.com/PV-Bhat/vibe-check-mcp-server.git .

# Install dependencies and build
RUN npm install && npm run build

# Run the MCP server
CMD ["node", "build/index.js"]
EOL

# Create .env file
echo "Enter your Gemini API key:"
read -p "API Key: " GEMINI_API_KEY

cat > .env << EOL
GEMINI_API_KEY=$GEMINI_API_KEY
EOL

chmod 600 .env  # Secure the API key file

# Create startup script
cat > start-vibe-check-docker.sh << 'EOL'
#!/bin/bash
cd ~/vibe-check-mcp
docker-compose up -d
EOL

chmod +x start-vibe-check-docker.sh

# Create a TCP wrapper script to route stdio to TCP port 3000
cat > vibe-check-tcp-wrapper.sh << 'EOL'
#!/bin/bash
# This script connects stdio to the Docker container's TCP port
exec socat STDIO TCP:localhost:3000
EOL

chmod +x vibe-check-tcp-wrapper.sh

# Detect OS for autostart configuration
OS="$(uname -s)"
case "${OS}" in
    Linux*)     OS="Linux";;
    Darwin*)    OS="Mac";;
    *)          OS="Unknown";;
esac

echo "Setting up auto-start for $OS..."

if [ "$OS" = "Mac" ]; then
    # Set up LaunchAgent for Mac
    PLIST_FILE="$HOME/Library/LaunchAgents/com.vibe-check-mcp-docker.plist"
    mkdir -p "$HOME/Library/LaunchAgents"
    
    cat > "$PLIST_FILE" << EOL
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.vibe-check-mcp-docker</string>
    <key>ProgramArguments</key>
    <array>
        <string>$HOME/vibe-check-mcp/start-vibe-check-docker.sh</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <false/>
</dict>
</plist>
EOL

    chmod 644 "$PLIST_FILE"
    launchctl load "$PLIST_FILE"
    
    echo "Created and loaded LaunchAgent for automatic Docker startup on login."
    
elif [ "$OS" = "Linux" ]; then
    # Set up systemd user service for Linux
    SERVICE_DIR="$HOME/.config/systemd/user"
    mkdir -p "$SERVICE_DIR"
    
    cat > "$SERVICE_DIR/vibe-check-mcp-docker.service" << EOL
[Unit]
Description=Vibe Check MCP Docker Container
After=docker.service

[Service]
ExecStart=$HOME/vibe-check-mcp/start-vibe-check-docker.sh
Type=oneshot
RemainAfterExit=yes

[Install]
WantedBy=default.target
EOL

    systemctl --user daemon-reload
    systemctl --user enable vibe-check-mcp-docker.service
    systemctl --user start vibe-check-mcp-docker.service
    
    echo "Created and started systemd user service for automatic Docker startup."
fi

# Start the container
echo "Starting Vibe Check MCP Docker container..."
./start-vibe-check-docker.sh

echo ""
echo "Vibe Check MCP Docker setup complete!"
echo ""
echo "To complete the setup, configure Cursor IDE:"
echo ""
echo "1. Open Cursor IDE"
echo "2. Go to Settings (gear icon) -> MCP"
echo "3. Click \"Add New MCP Server\""
echo "4. Enter the following information:"
echo "   - Name: Vibe Check"
echo "   - Type: Command"
echo "   - Command: $HOME/vibe-check-mcp/vibe-check-tcp-wrapper.sh"
echo "5. Click \"Save\" and then \"Refresh\""
echo ""
echo "Vibe Check MCP will now start automatically when you log in."
echo ""