What is MCP (Model Context Protocol)? How Forevibe Uses It for AI IDEs

What is Model Context Protocol (MCP)?

Model Context Protocol (MCP) is an open standard introduced by Anthropic in 2024. It defines a way for AI tools — code editors, chat interfaces, agents — to connect to external data sources and read structured context in real time.

Before MCP, getting context into an AI session meant manually copying documents, pasting architecture notes, or repeating yourself every session. MCP makes context a live, queryable resource your AI reads automatically — the same way a browser reads a web page.

An MCP server exposes data as resources (readable documents) and tools (callable functions). An MCP client — like Cursor, Windsurf, or Claude Code — connects to the server and can read those resources or call those tools during a coding session.

MCP Architecture

Your IDECursor / Windsurf Claude Code / GeminiMCP Client

MCP Protocol (JSON-RPC over stdio)

ForevibeYour Plan as structured resourcesMCP Server

Reads plan data

Your Plan.forevibe/ contract, stories, security rulesData Source

How Forevibe Uses MCP

Forevibe runs as an MCP server alongside your project. When you open Cursor, Windsurf, or Claude Code, they connect to Forevibe's MCP server and read your plan automatically — before you type a single prompt.

MCP Resources Forevibe Exposes

forevibe://plan/currentFull Plan

The complete plan for the active project — architecture, all stories, security rules, data contract, and delivery schedule. Use when you need the full picture.

forevibe://context/activeActive Vibe Context

Focused context for the current working story only — title, acceptance criteria, immediate dependencies, tech stack summary, and blocking invariants. Returns only what is necessary for the active story.

forevibe://rules-summaryRules Summary

Compact summary of all rule files — useful as a lightweight context injection when you need invariants without the full plan.

MCP Tools Forevibe Provides

complete_story— Mark a story done, update phase progress.

get_next_stories— Get the next stories ready to implement.

validate_against_plan— Check a code change against the plan contract.

check_security— Verify a route follows security rules.

check_naming— Validate entity/variable names against contract.

generate_scaffold— Get file stubs for a story.

get_progress— Overall plan progress summary.

get_blind_spots— Unresolved blind spots for the current phase.

generate_test_plan— Test plan based on story acceptance criteria.

Rule Files — MCP Without the Server

Not every IDE supports live MCP connections. Forevibe also generates static rule files your IDE reads at startup — no running server required:

IDE	Rule File	Format
Cursor	.cursor/rules/core.mdc	YAML frontmatter + Markdown (alwaysApply / globs)
Cursor	.cursor/rules/security.mdc	Scoped to all files, always applied
Cursor	.cursor/rules/database.mdc	Scoped to *.prisma, migrations
Windsurf	.windsurf/rules/core.md	Plain Markdown
Gemini	.gemini/styleguide.md	Plain Markdown
GitHub Copilot	.github/copilot-instructions.md	Plain Markdown
Claude Code	AGENTS.md	Plain Markdown

All rule files include a mandatory pre-flight checklist the AI runs before writing code, and a rule that requires updating the file to record any approved deviations.

Why MCP Solves Context Rot

Context rot is what happens when your AI loses track of decisions made in previous sessions. By session 8 or 10, it's guessing your auth strategy, making up naming conventions, and building outside your scope.

With MCP, your plan is not a document you paste — it's a live resource your AI reads automatically at the start of every session. The architecture is always in context. The security rules are always applied. The active story is always known.

Without MCP

✕Copy-paste architecture notes every session

✕Re-explain auth strategy each time

✕AI guesses naming conventions

✕Scope creep on every new feature

✕Security rules forgotten after session 3

With Forevibe MCP

✓Plan loaded automatically on session start

✓Architecture decisions always in context

✓Naming follows contract — every time

✓Scope locked to active story

✓Security invariants checked before every file

How to Set Up Forevibe as Your MCP Server

Generate your plan

Describe your product in the Forevibe discovery chat. Get 14+ plan artefacts: contract, stories, security rules, architecture, CI/CD.

Add to your IDE's MCP config

Point your IDE's MCP config at Forevibe. For Cursor and Claude Code, add to your mcp.json:

{
  "mcpServers": {
    "forevibe": {
      "command": "npx",
      "args": ["-y", "forevibe-mcp"],
      "env": {
        "FOREVIBE_TOKEN": "your-cli-token",
        "FOREVIBE_PLAN_ID": "your-plan-id"
      }
    }
  }
}

Sync rule files

Run forevibe sync to write scoped rule files for every IDE in your project. Uses content-hash validation — only writes when the plan has changed.

$ forevibe sync
  ✓ 5 rule files updated — Cursor · Windsurf · Gemini · Claude Code: IN SYNC

Get Started

Give Your AI a Plan to Follow

One discovery chat. A canonical plan. An MCP server that keeps your AI on-track — forever.

Start Free →Back to Homepage

Works with Cursor · Windsurf · Claude Code · GitHub Copilot · Gemini Code Assist