Yeti

Yeti

[npm] [CI] [License: MIT] [Yeti MCP on mcprush]

An MCP server for product design with Claude. It takes a project from the problem to a verified scope: requirements, user stories, RICE priorities and flow diagrams. Then it sends the work to Jira.

[The Yeti dashboard: phases, what is missing to move on, and musts with their user stories]

Quick start

Add Yeti to Claude Desktop, in claude_desktop_config.json, then restart Claude Desktop:

{  "mcpServers": {    "yeti": {      "command": "npx",      "args": ["-y", "yeti-mcp"],      "env": { "PRODUCT_DESIGN_DB": "/Users/you/yeti/yeti.sqlite" }    }  }}

Set PRODUCT_DESIGN_DB to a file in a folder you keep. With npx the package lives in a cache that can be cleared, and a database stored there would go with it. Yeti needs Node.js 22.13 or later.

Then ask Claude:

Create a project "Quotes for craftsmen" with Yeti. Problem: writing quotes takes hours. Users: plumbers and painters. Goal: a quote in five minutes.

Open the Yeti dashboard.

How it works

A project goes through five phases, in order:

1. discovery: problem, users and goal
2. definition: requirements (MoSCoW) and user stories
3. prioritization: RICE scoring of ideas
4. flows: Mermaid flow diagrams
5. verification: every must requirement completed and covered by a user story, then the project closes

Projects have a mode, chosen at creation:

• strict (default): a phase advances only when its requirements are met. advance_phase tells you what is missing.
• free: phases advance regardless, and the response lists what was skipped.

Tools

Projects

Requirements and user stories

Prioritization and flows

Import, export and dashboard

Jira

Requirements, stories, RICE scores and flows accept an optional projectId to link them to a project.

Install from source

You need Node.js 22.13 or later (Yeti uses the built-in node:sqlite module).

git clone https://github.com/macorifice/yeti.gitcd yetinpm installnpm run build

Then add it to claude_desktop_config.json, using the absolute path to dist/index.js on your machine:

{  "mcpServers": {    "yeti": {      "command": "node",      "args": ["/absolute/path/to/yeti/dist/index.js"]    }  }}

Restart Claude Desktop after editing the file.

Usage

Once connected, you work with Yeti by talking to Claude. A typical project looks like this.

1. Create a project

Create a project "Quotes for craftsmen". Problem: writing quotes takes hours. Users: plumbers and painters. Goal: a quote in five minutes.

Yeti creates the project in the discovery phase.

2. Move through the phases

• definition: add at least one requirement and one user story linked to it.
• prioritization: score the ideas with RICE.
• flows: draw at least one flow diagram.
• verification: every must requirement is done and covered by a user story.

In strict mode (the default), Yeti will not advance until the phase is complete, and it tells you what is missing. In free mode, it advances and lists what it skipped. You can switch with set_project_mode.

3. Work on the backlog

• Edit or delete requirements and stories.
• Mark acceptance criteria as done.
• Search across a project.
• Duplicate a project to reuse it as a template.
• Import requirements from a CSV file.

4. Export

Export the project backlog as Markdown and save it to a file.

With save: true, the file is written to data/exports/ next to the database.

Good to know

• Data is stored locally, in data/yeti.sqlite. The content still passes through the chat, so do not put sensitive data in it.
• RICE scores are the numbers you enter. Yeti sorts them; it does not estimate them.

Case study

A small project from requirements to Jira, using the Mastro example: creating the project, requirements and user stories, RICE prioritisation, a flow diagram, the verification gate, sending to Jira, and keeping the status in sync.

[Case study: from requirements to Jira]

Dashboard

Yeti has a read-only dashboard for the design side of your projects: the phase each project is in, what is missing to move on, which musts are covered by user stories, acceptance criteria, RICE scores and flow diagrams. It does not show a task board: execution belongs in Jira.

[User stories with their criteria, RICE scores and a flow diagram in the Yeti dashboard]

Open it from Claude:

Open the Yeti dashboard.

Claude calls open_dashboard and gives you an address such as http://127.0.0.1:4321. Or start it from a terminal:

npx yeti-mcp dashboard --port 4321

• It listens on 127.0.0.1 only, so it is not reachable from other machines, and it refuses requests for other host names.
• It reads the same database as the MCP server and refreshes every 10 seconds.
• Jira keys become links when JIRA_SITE is set.
• Diagrams are drawn with Mermaid, loaded from a CDN. Without a connection they are shown as text.

export_dashboard still writes a static snapshot to data/exports/dashboard.html, for sharing.

Credentials

Yeti works without any account. Only one tool talks to an external service:

• Everything else (projects, requirements, stories, RICE, flows, verification, export, search) runs locally and needs no credentials.
• push_to_tracker creates items in Jira, when the project is bound to Jira. It needs three environment variables:

Set them in your shell profile, for example in ~/.zshrc:

export JIRA_SITE="https://your-team.atlassian.net"export JIRA_EMAIL="[email protected]"export JIRA_API_TOKEN="your-token-here"

Never put the token in the repository, in a config file you commit, or in a chat. If a token is exposed, revoke it in the same page and create a new one.

For GitHub Issues, set GITHUB_REPO (owner/repo) and GITHUB_TOKEN instead. Without the variables for the bound tracker, sending is refused and the message names what is missing. Dry-run previews work without them.

Yeti supports two work trackers, Jira and GitHub Issues. A project is bound to one of them with set_project_tracker. Each sits behind a common interface, so more can be added: see CONTRIBUTING.md.

For GitHub Issues, set GITHUB_REPO to owner/repo and GITHUB_TOKEN to a token with issues write access. Requirements become issues labelled requirement and priority: must (or should, could, wont); user stories become issues labelled user-story. An item is done when its issue is closed. The GitHub integration has been checked end-to-end against a real repository: an item was sent, its issue was closed by hand, and the sync marked the item done.

Data

Data is stored in SQLite. From a source checkout the default is data/yeti.sqlite inside the project folder; with npx, set PRODUCT_DESIGN_DB as shown in the quick start. Earlier versions used data/db.json: it is imported automatically the first time the new version runs, and then left untouched. To use another location, set the PRODUCT_DESIGN_DB environment variable:

"env": { "PRODUCT_DESIGN_DB": "/absolute/path/to/yeti.sqlite" }

Test

npm test

The test starts the server on a temporary database and checks every tool and the phase flow.

Status

Stable since 1.0.0. The tools, their inputs and the data format are covered by semantic versioning: breaking changes will come with a new major version.

Sponsor

If Yeti is useful to you, you can support its development through GitHub Sponsors.

License

MIT. See LICENSE.