# starecz/karea-mcp [Health: Active]

**Category:** 🏢 Workplace & Productivity  
**Repository:** https://github.com/starecz/karea-mcp  
**GitHub Stars:** 1  
**npm Downloads (last month):** 245  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/starecz-karea-mcp

## Description
MCP server for Karea task manager. 44 tools to create, edit, close, recap, and link your dev tasks while Claude Code or Cursor codes. Per-task open questions, attached resources, Jira links, productivity recap. npx -y karea-mcp

## Tools
Capabilities this server exposes over MCP:

- **karea_list_projects** — List all Karea projects with their IDs
- **karea_list_tasks** — List tasks in a project. Defaults to open tasks (open, in_progress, blocked, review, backlog) capped at 200 to keep responses small. To see closed tasks pass status="done" and optionally closedSince (e.g. "14d", "7d", "24h"). To list everything, pass status="all". Optional filters (category, priority, assignee, search) narrow the result server-side — prefer them over post-filtering.
- **karea_create_task** — Create a new task in a project and return it with its visual ID (e.g. KA42), status, priority and category. Defaults when omitted: status open, priority 3, the first category of the project. Use karea_quick_task to log something already finished, or karea_doing for work in progress.
- **karea_edit_task** — Update fields of an existing task (title, status, priority, deadline, category, assignee, description, tags, or add a note) located by visual ID, name or UUID. Only the fields you pass change; the rest are left untouched. Returns the updated task.
- **karea_close_task** — Mark a task as done: sets status to done and stamps the close time. Reports any unmet closing requisites first unless confirm is set. To close several tasks at once use karea_done.
- **karea_delete_task** — Permanently delete a task and its history. Irreversible; requires confirm=true. To merely close a task instead, use karea_close_task.
- **karea_quick_task** — Log something you already finished as a done task (it shows up in Recap) and return it. Status is always done; relative-time params set when it happened. For in-progress work use karea_doing instead.
- **karea_doing** — Create a task you are working on right now (status: in_progress)
- **karea_view_task** — Return one task with all its details (status, priority, deadline, category, description, notes, requisites, links), located by visual ID, name or UUID. Pass includeContext=true to also inline the task's AI Context in the response — avoids a follow-up karea_get_context round-trip. Read-only.
- **karea_view_tasks** — Return details for MANY tasks in one response. Pass an array of task identifiers (visualIds, names, or UUIDs) and get one consolidated response with a block per task, separated by dividers. Use this instead of calling karea_view_task N times when you want to inspect a batch. Max 50 per call. Read-only.
- **karea_create_project** — Create a new Karea project owned by you and seed it with the default categories (Coding, Testing, Documenting, Reviewing). Returns the new project id. To add a category to an existing project, use karea_create_category instead.
- **karea_delete_project** — Permanently delete a project and everything inside it (tasks, categories, notes, history). Irreversible; requires confirm=true.
- **karea_create_category** — Create a new category (a task bucket) inside an existing project and return it. To create a whole project, use karea_create_project.
- **karea_delete_category** — Permanently delete a category AND every task inside it, including history. Irreversible; requires confirm=true. To delete a single task instead, use karea_delete_task.
- **karea_done** — Mark several tasks as done in one call, each given by visual ID or name; returns a per-task result. For a single task with closing-requisite checks, use karea_close_task.
- **karea_share_project** — Give another user access to a project by email at a chosen role (owner, editor, commenter or viewer). Records the share so that user can see and, per role, edit the project.
- **karea_ask** — Send a natural-language request to the Karea AI assistant, which may read or modify your tasks to carry it out, and return its reply. Consumes your monthly AI usage allowance.
- **karea_recap** — Return a summary of recent activity (tasks created, closed and updated) over a recent time window. Read-only; handy for standups and reviews.
- **karea_get_markdown** — Read the markdown document attached to a task. This is the task's knowledge base — it contains investigation findings, technical and functional documentation, root cause analysis, solution design, implementation notes, and any other long-form content the task has accumulated. Always read this before working on a task to avoid duplicating past research.
- **karea_set_markdown** — Write the markdown document for a task. Overwrites any existing content. Use this to persist: investigation findings and research, technical documentation (architecture, APIs, schemas), functional documentation (requirements, acceptance criteria, user flows), root cause analysis and debugging logs, solution design — planned or implemented, risks, trade-offs, and open questions. This is the single source of truth for everything learned about this task. Always append to existing content (read first with karea_get_markdown) rather than replacing it, unless restructuring.
- **karea_get_context** — Read the task's Context — titled entries of AI working memory that hold the FULL HISTORY of a task (not just its current state): what was tried, decided, discovered, and abandoned along the way. ALWAYS read this first when picking a task up so you inherit the journey instead of re-deriving it. Each entry shows who/when/how (user or mcp) it was created and last edited. When you learn something new, ADD to the relevant entry with karea_set_context — do not overwrite the history. Distinct from notes (human-readable updates) and the markdown doc (long-form documentation).
- **karea_set_context** — Write a titled entry of the task's Context — the AI-facing cross-session working memory. Context tracks the FULL HISTORY of a task, not just its current state: what was tried, what worked, what failed, what was decided and why. Update incrementally so the journey is preserved (never overwrite the whole entry with "current status" — read first with karea_get_context, append/refine, then write back). Context is your DEFAULT save target: after every plan, finding, decision, or gotcha, persist it here proactively under titles like "Plan", "Findings", "Decisions", "Gotchas", "Attempted". Upserts by title: same title overwrites THAT entry only; other entries are untouched. Pass empty context to delete the entry. Use karea_add_note only for human-facing updates and karea_set_markdown for long-form docs — but keep Context up to date either way.
- **karea_list_questions** — List open questions (unresolved decisions or blockers) in a project, newest first. Defaults to status open; pass status to include answered, cancelled or all. Read-only.
- **karea_create_question** — Create an open question (a decision or blocker to resolve) in a project, optionally linked to tasks, and return it with its short ID (e.g. KAQ3).
- **karea_answer_question** — Answer an open question, located by short ID or text match: sets its answer and flips its status to answered. Returns the updated question.
- **karea_edit_question** — Edit an open question: change its text, status (open, answered or cancelled), answer, or linked tasks. Only the fields you pass change. Returns the updated question.
- **karea_delete_question** — Permanently delete an open question. Irreversible. To keep it but mark it resolved, set its status to cancelled via karea_edit_question instead.
- **karea_list_resources** — List resources (text notes & files). With a projectId it returns every resource belonging to that project - whether assigned to it directly, linked to one of its tasks, or filed under a folder named after the project (e.g. knowledge-base docs). Omit projectId to list all your resources, including unfiled ones. All filters combine freely (name query, folder, type, mime, size range).
- **karea_get_resource** — Return a text resource with its full content and metadata, by ID. Read-only.
- **karea_create_resource** — Create a text resource (a note or document) in a project or folder and return it with its ID. To attach an existing resource to a task, use karea_link_resource_to_task.
- **karea_update_resource** — Overwrite a text resource content and/or metadata, by ID, and return the updated resource. Replaces the existing content rather than appending.
- **karea_delete_resource** — Permanently delete a resource (text or file) by ID. Irreversible. To only detach it from a task, use karea_unlink_resource_from_task.
- **karea_upload_resource** — Upload a binary file as a resource (base64-encoded)
- **karea_link_resource_to_task** — Link an existing resource (text or file) to a task. The resource and task must belong to the same user/project scope. Use this to attach release notes, design docs, references, etc. to one or more tasks. To link a resource to multiple tasks, call this once per task.
- **karea_unlink_resource_from_task** — Remove the link between a resource and a task. Does not delete either side.
- **karea_list_notes** — List the notes (human-readable updates) on a task, newest first. Read-only.
- **karea_link_session** — Link your current AI coding session (Claude Code, OpenCode, Codex, Cursor, Aider) to a Karea task so the user can see the session history for that task and copy a command to resume the session later. Call this once per task you're working on. For Claude Code, pass sessionId as the CLI session id; for OpenCode use its session id; etc.
- **karea_list_sessions** — List AI coding sessions linked to a task (provider, sessionId, label, last active, resume command). Read-only.
- **karea_unlink_session** — Remove a previously-linked AI session from a task. Use the row ID from karea_list_sessions or karea_link_session.
- **karea_add_note** — Add a note to a task. Notes are human-readable updates/observations (the user reads them). For private AI working memory that persists across sessions, use karea_set_context instead.
- **karea_edit_note** — Change the text of an existing note on a task, by note ID, and return the updated note.
- **karea_delete_note** — Permanently delete a note from a task, by note ID. Irreversible.
- **karea_create_subtask** — Create a subtask under a parent task. Accepts the parent by visual ID (e.g. KPL77), name, or UUID. Supports the same params as karea_create_task.
- **karea_list_subtasks** — List subtasks of a parent task. Accepts the parent by visual ID, name, or UUID.
- **karea_add_requisite** — Add a closing requisite (a checklist item that must be completed before the task may be closed) to a task, and return it.
- **karea_toggle_requisite** — Mark a closing requisite complete or incomplete, by ID. This affects whether karea_close_task warns about unmet requisites.
- **karea_delete_requisite** — Permanently delete a closing requisite from a task, by ID. Irreversible.
- **karea_get_jira_link** — Return the linked JIRA issue (key and URL) for a task, if one exists. Read-only.
- **karea_link_jira** — Link a Karea task to a JIRA issue by issue key (e.g. PROJ-123)
- **karea_unlink_jira** — Remove the JIRA link from a Karea task

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "karea-mcp": {
    "command": "npx",
    "args": ["-y","karea-mcp"],
    "env": {
      "KAREA_API_KEY": "",
      "KAREA_URL": ""
    }
  }
}
```

**Requires environment variables:** `KAREA_API_KEY`, `KAREA_URL` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What starecz/karea-mcp MCP server does

The starecz/karea-mcp MCP server connects an MCP client to Karea, a task manager. Its README lists 49 tools for working with tasks, projects, categories, questions, resources, sessions, requisites, Jira links, and recaps. The supplied tool catalogue includes operations for creating, editing, closing, deleting, viewing, and listing work items.

Tasks can be identified by visual ID, name, or UUID in several operations. A task can include a status, priority, deadline, category, assignee, description, tags, notes, requisites, links, long-form markdown, and AI-oriented context. The server also supports quick logging for completed work and a separate operation for recording work currently in progress.

## How it works

An MCP-compatible client starts the server locally with npm and passes Karea connection settings through environment variables. The client then discovers the available tools and can invoke them during a coding session.

Task listing defaults to open work and limits responses to 200 items. Status, category, priority, assignee, and search filters can narrow results on the server. Closed work can be queried with a status and an optional relative time such as `14d`, `7d`, or `24h`; `all` requests all statuses. Batch task inspection is available through `karea_view_tasks`, which accepts up to 50 identifiers in one call.

The task knowledge model has separate storage areas. Markdown is intended for long-form research, requirements, designs, debugging records, and implementation notes. Context stores titled, AI-facing history about decisions, attempts, findings, and gotchas. Notes are intended for human-facing updates. Existing markdown should be read before replacing it, because the write operation overwrites the current document.

## Setup and configuration

Install and run the starecz/karea-mcp MCP server with:

```bash
npx -y karea-mcp
```

For Claude Code, add an MCP entry to `~/.claude.json` or use `claude mcp add`. The documented configuration sets the command to `npx`, passes `-y` and `karea-mcp`, and provides `KAREA_API_KEY` plus `KAREA_URL`. The example URL is `https://karea.app`.

For Cursor, add the server to `.cursor/mcp.json` in a project or to `~/.cursor/mcp.json` globally. The documented Cursor example provides `KAREA_API_KEY`; it does not include `KAREA_URL`. The README directs users to the Karea dashboard API-key page to obtain a key.

## Tools and capabilities

The starecz/karea-mcp MCP server supports these workflows:

- Create projects, categories, tasks, subtasks, questions, notes, and text resources.
- Edit or permanently delete tasks, projects, categories, questions, notes, and resources. Destructive operations require confirmation where documented.
- Mark individual or multiple tasks done, start an in-progress task, or log already completed work.
- Read and write task markdown, AI context, notes, requisites, and attached resources.
- Add, answer, edit, list, or remove open questions linked to projects or tasks.
- Link and unlink resources, Jira items, and sessions.
- Share projects with another user using owner, editor, commenter, or viewer roles.
- Produce recent activity recaps for standups or reviews.

The `karea_ask` tool sends a natural-language request to Karea’s AI assistant. According to the tool description, that assistant may read or modify tasks and consumes the account’s monthly AI usage allowance.

## Limitations and notes

The server requires a Karea API key. The README does not describe pricing, API limits, or whether the Karea account or AI allowance is free or paid. The tool descriptions identify irreversible deletion for tasks, projects, categories, questions, notes, and resources; confirmation is required for the destructive operations where specified.

The provided material does not document a hosted remote endpoint. The documented installation runs the server locally through `npx`. The README names Claude Code and Cursor as configuration targets, while other MCP-compatible clients may work but are not individually configured in the supplied material.

_Full upstream README: https://allmcps.com/mcp/starecz-karea-mcp/readme_