# Yeti MCP server

> Enables AI clients to manage product design lifecycles from discovery and requirements to RICE prioritization, flow diagrams, and Jira synchronization.

- Repository: https://github.com/macorifice/yeti
- Page: https://hostedmcp.org/servers/macorifice/yeti
- Transport: stdio
- Stars: 3
- License: MIT
- Latest version: 1.1.0

## Install

### Claude Code

```sh
claude mcp add --env 'JIRA_API_TOKEN=<YOUR_JIRA_API_TOKEN>' yeti -- npx -y yeti-mcp
```

### Cursor (`~/.cursor/mcp.json`)

```json
{
  "mcpServers": {
    "yeti": {
      "command": "npx",
      "args": [
        "-y",
        "yeti-mcp"
      ],
      "env": {
        "JIRA_API_TOKEN": "<YOUR_JIRA_API_TOKEN>"
      }
    }
  }
}
```

### VS Code (`.vscode/mcp.json`)

```json
{
  "servers": {
    "yeti": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "yeti-mcp"
      ],
      "env": {
        "JIRA_API_TOKEN": "<YOUR_JIRA_API_TOKEN>"
      }
    }
  }
}
```

### VS Code CLI

```sh
code --add-mcp '{"name":"yeti","type":"stdio","command":"npx","args":["-y","yeti-mcp"],"env":{"JIRA_API_TOKEN":"<YOUR_JIRA_API_TOKEN>"}}'
```

### Claude Desktop (`claude_desktop_config.json`)

```json
{
  "mcpServers": {
    "yeti": {
      "command": "npx",
      "args": [
        "-y",
        "yeti-mcp"
      ],
      "env": {
        "JIRA_API_TOKEN": "<YOUR_JIRA_API_TOKEN>"
      }
    }
  }
}
```

### Codex

```sh
codex mcp add yeti --env 'JIRA_API_TOKEN=<YOUR_JIRA_API_TOKEN>' -- npx -y yeti-mcp
```

### Codex config.toml (`~/.codex/config.toml`)

```toml
[mcp_servers.yeti]
command = "npx"
args = ["-y", "yeti-mcp"]

[mcp_servers.yeti.env]
JIRA_API_TOKEN = "<YOUR_JIRA_API_TOKEN>"
```

### Gemini CLI

```sh
gemini mcp add -s user -e 'JIRA_API_TOKEN=<YOUR_JIRA_API_TOKEN>' yeti npx -- -y yeti-mcp
```

### Gemini settings.json (`~/.gemini/settings.json`)

```json
{
  "mcpServers": {
    "yeti": {
      "command": "npx",
      "args": [
        "-y",
        "yeti-mcp"
      ],
      "env": {
        "JIRA_API_TOKEN": "<YOUR_JIRA_API_TOKEN>"
      }
    }
  }
}
```

## Environment variables

| Name | Required | Secret | Description |
|---|---|---|---|
| `JIRA_API_TOKEN` | no | yes | Atlassian API token. Only needed for the Jira tools. |
| `JIRA_EMAIL` | no | no | Email of the Atlassian account. Only needed for the Jira tools. |
| `JIRA_SITE` | no | no | Jira site, e.g. https://your-team.atlassian.net. Only needed for the Jira tools. |
| `PRODUCT_DESIGN_DB` | no | no | Absolute path of the SQLite database file. Set it to a folder you keep when running with npx. |

## Tools (35)

- `create_project`: Create a design project. It starts in the 'discovery' phase: problem, users and goal are required. Mode 'strict' (default) blocks advancing until each phase is complete; 'free' allows advancing and reports what was skipped.
- `list_projects`: List projects with their id, name, phase and status. Use it to find a projectId.
- `update_requirement`: Change a requirement's title, description or priority. Only the fields you pass are changed.
- `delete_requirement`: Delete a requirement. It is also removed from the requirementIds of any user story that covered it.
- `delete_user_story`: Delete a user story.
- `set_criterion_status`: Mark one acceptance criterion of a user story as done or not done. The index is 0-based, in the order of the criteria.
- `archive_project`: Archive or unarchive a project. Archived projects are hidden from list_projects by default. Nothing is deleted.
- `set_project_mode`: Change a project's mode: 'strict' or 'free'. Applies from the next phase change.
- `update_project`: Change a project's name, problem, users or goal. Only the fields you pass are changed.
- `search_items`: Search requirements and user stories by text (case-insensitive). Optionally limit to one project.
- `duplicate_project`: Create a new project from an existing one, copying its requirements and user stories as open items. Useful as a template for a new client or product. Statuses and RICE scores are not copied.
- `import_requirements`: Import requirements and user stories from CSV text, in the format produced by export_backlog. Requirement rows need type and title; story rows need persona, goal, benefit and criteria (separated by ' | '). Story-to-requirement links are not restored.
- `push_to_jira`: Create Jira issues for a project: one Task per requirement and one Story per user story. Items already sent are skipped. With update: true, also refreshes the issues already linked. dryRun (default true) only lists what would be sent.
- `sync_from_jira`: Read the status of linked Jira issues and mark items done in Yeti when their Jira issue is done. Requirements become done; stories get all their criteria ticked. Read-only on Jira.
- `project_summary`: Summarise a project's progress: requirements by priority and status, story coverage of musts, acceptance criteria done, RICE leader, Jira links and what is missing to close.
- `list_stories`: List user stories, optionally for one project, with their ids, criteria state and Jira key. Use it to find a storyId.
- `delete_project`: Permanently delete a project with its requirements and user stories. Requires confirm: true. This cannot be undone; issues already created in Jira are not touched.
- `update_user_story`: Change a user story's persona, goal, benefit, linked requirements or acceptance criteria. Only the fields you pass change. Changing the criteria resets their done state.
- `list_flows`: List the flow diagrams saved in a project, with their index. Use the index to refer to a diagram.
- `delete_flow`: Delete one saved flow diagram from a project, by the index shown by list_flows.
- `export_dashboard`: Write a read-only HTML dashboard to data/exports/dashboard.html: phases, what is missing, musts covered by stories, RICE scores and flow diagrams. Open the file in a browser.
- `open_dashboard`: Start the local, read-only Yeti dashboard and return its address (http://127.0.0.1:...). It shows phases, what is missing, musts and their stories, RICE and flows, and refreshes by itself. It runs on this computer only, while Yeti runs.
- `add_decision`: Record a design decision for a project: what was chosen, why, and which alternatives were rejected. Decisions are kept with the project, so the reasons outlive the chat.
- `list_decisions`: List the design decisions recorded for a project, oldest first.
- `list_templates`: List the starter project templates: a marketplace MVP and a customer self-service portal. Use one with create_project_from_template.
- `create_project_from_template`: Create a project from a starter template. It starts in discovery with its requirements and user stories open, linked to each other. Adapt them afterwards with the usual tools.
- `get_project`: Show a project's status: current phase, what is missing to advance, and linked items.
- `advance_phase`: Move to the next phase. In 'strict' mode, it lists what is missing and does not advance. In 'free' mode, it advances and reports what was skipped. After 'verification' it closes the project.
- `add_requirement`: Record a product requirement with a MoSCoW priority (must, should, could, wont).
- `list_requirements`: List requirements, optionally filtered by priority, status and project. Most important first.
- `set_requirement_status`: Mark a requirement as open or done.
- `add_user_story`: Create a user story in the format 'As a <persona> I want <goal> so that <benefit>', with acceptance criteria.
- `prioritize_rice`: Compute RICE scores (Reach × Impact × Confidence ÷ Effort) for a list of ideas and sort them. With projectId, saves the result to the project.
- `map_user_flow`: Generate a Mermaid flowchart from a list of steps. Steps are linked in order; a decision (diamond) gets a 'Yes' edge to the next step, or to 'yes' if set, and a 'No' edge to 'no' if set. With projectId, saves the diagram to the project.
- `export_backlog`: Export a project backlog as Markdown or CSV: requirements (most important first) and user stories.

## FAQ

### What is the difference between strict and free modes?

In strict mode, a phase only advances when all requirements are met; in free mode, phases advance regardless and list what was skipped.

### Where is the project data stored?

Data is stored locally in a SQLite database.
