# starecz/karea-mcp [Health: Active]

**Category:** 🏢 Workplace & Productivity  
**Repository:** https://github.com/starecz/karea-mcp  
**GitHub Stars:** 1  
**npm Downloads (last month):** 1436  
**Views:** 5  
**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_projects** — Projects and their categories: list, create, delete, share, and manage the categories inside a project.

Pass one of these as `action`, with its arguments in `params`:
- karea_list_projects - List all Karea projects with their IDs [no parameters]
- karea_create_project - Create a new Karea project owned by you and seed it with the default categories (Coding, Testing, Documenting, Reviewing). [required: name]
- karea_delete_project - Permanently delete a project and everything inside it (tasks, categories, notes, history). [required: name; optional: confirm]
- karea_share_project - Give another user access to a project by email at a chosen role (owner, editor, commenter or viewer). [required: project, email; optional: role]
- karea_create_category - Create a new category (a task bucket) inside an existing project and return it. [required: name; optional: projectId]
- karea_delete_category - Permanently delete a category AND every task inside it, including history. [required: name; optional: projectId]

For the full parameter schema of any action, call karea_help with that action name.
- **karea_tasks** — Tasks: find them, read them, create them, change them, close them. The main entry point - start here.

Pass one of these as `action`, with its arguments in `params`:
- karea_list_tasks - List tasks in a project. [optional: projectId, status, closedSince, limit, category, priority, assignee, search]
- karea_view_task - Return one task with all its details (status, priority, deadline, recurrence, category, description, notes, requisites, links), located by visual ID, name or UUID. [required: task; optional: projectId, includeContext]
- karea_view_tasks - Return details for MANY tasks in one response. [required: tasks; optional: projectId, includeContext, includeMarkdown]
- karea_create_task - Create a new task in a project and return it with its visual ID (e.g. [required: name; optional: category, priority, sla, description, markdown, source, closingRequisites, tags, parentId, jiraIssueKey, projectId, aiSessionId, toolType, sessionLabel]
- 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. [required: task; optional: name, priority, status, reviewStage, sla, description, markdown, category, note, tags, clearTags, closingRequisites, clearClosingRequisites, jiraIssueKey, linkTasks, linkType, unlinkTasks, projectId, aiSessionId, toolType, sessionLabel]
- karea_edit_tasks - Apply the SAME change to many tasks in ONE request - status, priority, category, deadline, assignee, or a note. [required: tasks; optional: projectId, status, priority, category, sla, note]
- karea_close_task - Mark a task as done: sets status to done and stamps the close time. [required: task; optional: resolution, projectId, aiSessionId, toolType, sessionLabel]
- karea_delete_task - Permanently delete a task and its history. [required: task; optional: confirm, projectId]
- karea_quick_task - Log something you already finished as a done task (it shows up in Recap) and return it. [required: description; optional: source, projectId, aiSessionId, toolType, sessionLabel]
- karea_doing - Create a task you are working on right now (status: in_progress) [required: description; optional: category, priority, sla, projectId, aiSessionId, toolType, sessionLabel]
- karea_done - Mark several tasks as done in one call, each given by visual ID or name; returns a per-task result. [required: tasks; optional: projectId]

For the full parameter schema of any action, call karea_help with that action name.
- **karea_subtasks** — Subtasks and closing requisites - the checklist a task has to satisfy before it can be closed.

Pass one of these as `action`, with its arguments in `params`:
- karea_create_subtask - Create a subtask under a parent task. [required: parent, title; optional: category, priority, sla, description, markdown, source, closingRequisites, tags, jiraIssueKey, projectId, aiSessionId, toolType, sessionLabel]
- karea_list_subtasks - List subtasks of a parent task. [required: parent; optional: projectId]
- 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. [required: task, description; optional: projectId]
- karea_toggle_requisite - Mark a closing requisite complete or incomplete, by ID. [required: task, requisiteId, completed; optional: projectId]
- karea_delete_requisite - Permanently delete a closing requisite from a task, by ID. [required: task, requisiteId; optional: projectId]

For the full parameter schema of any action, call karea_help with that action name.
- **karea_notes** — Notes on a task - human-readable updates the user reads - plus the sticky-note scratch board. For private cross-session memory use karea_docs (set_context).

Pass one of these as `action`, with its arguments in `params`:
- karea_list_notes - List the notes (human-readable updates) on a task, newest first. [required: task; optional: projectId]
- karea_add_note - Add a note to a task - or the same note to many tasks at once, via `tasks`. [required: content; optional: task, tasks, projectId, aiSessionId, toolType, sessionLabel]
- karea_edit_note - Change the text of an existing note on a task, by note ID, and return the updated note. [required: task, noteId, content; optional: projectId, aiSessionId, toolType, sessionLabel]
- karea_delete_note - Permanently delete a note from a task, by note ID. [required: task, noteId; optional: projectId]
- karea_list_sticky_notes - List the user's sticky notes - the scratch pad: short reminders, commands, URLs. [optional: projectId]
- karea_create_sticky_note - Pin a short note to the user's sticky board - a command, a URL, a couple of lines to remember. [required: content; optional: title, color, projectId, pinned]
- karea_edit_sticky_note - Change a sticky note: its text, title, colour, pin state, or which project it belongs to. [required: noteId; optional: content, title, color, projectId, pinned]
- karea_delete_sticky_note - Delete a sticky note. [required: noteId]

For the full parameter schema of any action, call karea_help with that action name.
- **karea_docs** — A task's long-form markdown document and its AI Context (private working memory that survives across sessions).

Pass one of these as `action`, with its arguments in `params`:
- karea_get_markdown - Read the markdown document attached to a task. [required: task; optional: projectId]
- karea_set_markdown - Write the markdown document for a task. [required: task, markdown; optional: projectId, aiSessionId, toolType, sessionLabel]
- 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. [required: task; optional: projectId]
- karea_set_context - Write a titled entry of the task's Context - the AI-facing cross-session working memory. [required: task, context; optional: title, projectId, aiSessionId, toolType, sessionLabel]

For the full parameter schema of any action, call karea_help with that action name.
- **karea_questions** — Open questions: things you are waiting on an answer for. Create, answer, edit, delete.

Pass one of these as `action`, with its arguments in `params`:
- karea_list_questions - List open questions (unresolved decisions or blockers) in a project, newest first. [optional: projectId, status]
- 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. [required: question; optional: projectId, markdown, taskIds]
- karea_answer_question - Answer an open question, located by short ID or text match: sets its answer and flips its status to answered. [required: questionId, answer]
- karea_edit_question - Edit an open question: change its text, status (open, answered or cancelled), answer, or linked tasks. [required: questionId; optional: question, answer, status, markdown, taskIdsAdd, taskIdsRemove]
- karea_delete_question - Permanently delete an open question. [required: questionId]

For the full parameter schema of any action, call karea_help with that action name.
- **karea_resources** — The file/document library: list, read, create, update, upload, delete, and attach resources to tasks.

Pass one of these as `action`, with its arguments in `params`:
- karea_list_resources - List resources (text notes & files). [optional: projectId, query, folder, type, mime, minSize, maxSize]
- karea_get_resource - Return a resource with its full content and metadata, by ID. [required: resourceId]
- karea_create_resource - Create a text resource (a note or document) in a project or folder and return it with its ID. [required: name, content; optional: projectId, folder]
- karea_update_resource - Overwrite a text resource content and/or metadata, by ID, and return the updated resource. [required: resourceId; optional: name, content, folder]
- karea_upload_resource - Upload a binary file as a resource (base64-encoded) [required: name, data; optional: mimeType, folder, taskId]
- karea_delete_resource - Permanently delete a resource (text or file) by ID. [required: resourceId]
- karea_link_resource_to_task - Link an existing resource (text or file) to a task. [required: resourceId, task; optional: projectId]
- karea_unlink_resource_from_task - Remove the link between a resource and a task. [required: resourceId, task; optional: projectId]

For the full parameter schema of any action, call karea_help with that action name.
- **karea_meetings** — Meetings, and the tasks and open questions attached to them.

Pass one of these as `action`, with its arguments in `params`:
- karea_list_meetings - List meetings. [optional: scope, from, to, projectId]
- karea_view_meeting - Return one meeting in full: time, location, project, attendees, prep notes, transcript, linked tasks and linked open questions. [required: meetingId]
- karea_create_meeting - Create a meeting. [required: title, startAt, endAt; optional: description, location, projectId, notes, attendees]
- karea_edit_meeting - Update a meeting. [required: meetingId; optional: title, startAt, endAt, description, location, projectId, notes, transcript]
- karea_delete_meeting - Delete a meeting permanently. [required: meetingId, confirm]
- karea_link_task_to_meeting - Link an EXISTING task to a meeting (discussed at / arising from it). [required: meetingId, task; optional: projectId]
- karea_unlink_task_from_meeting - Remove the link between a task and a meeting. [required: meetingId, task; optional: projectId]
- karea_link_question_to_meeting - Link an EXISTING open question to a meeting, so it is raised there. [required: meetingId, questionId]
- karea_unlink_question_from_meeting - Remove the link between an open question and a meeting. [required: meetingId, questionId]

For the full parameter schema of any action, call karea_help with that action name.
- **karea_reminders** — Reminders: see what is due, create one, snooze it, dismiss it, mark it done.

Pass one of these as `action`, with its arguments in `params`:
- karea_check_reminders - Return the caller's upcoming and past-due reminders. [optional: taskId, includeDone]
- karea_create_reminder - Schedule a reminder on a task. [required: task, fireAt; optional: title, emailOptIn]
- karea_snooze_reminder - Snooze a firing reminder by N minutes. [required: reminderId, minutes]
- karea_dismiss_reminder - Dismiss a reminder - cancels it so it will not fire again. [required: reminderId]
- karea_mark_reminder_done - Fulfill a reminder: closes both the reminder AND the underlying task (status = done). [required: reminderId]

For the full parameter schema of any action, call karea_help with that action name.
- **karea_integrations** — JIRA links on a task, and AI CLI sessions linked to a task.

Pass one of these as `action`, with its arguments in `params`:
- karea_get_jira_link - Return the linked JIRA issue (key and URL) for a task, if one exists. [required: task; optional: projectId]
- karea_link_jira - Link a Karea task to a JIRA issue by issue key (e.g. [required: task, issueKey; optional: projectId]
- karea_unlink_jira - Remove the JIRA link from a Karea task [required: task; optional: projectId]
- 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. [required: task, provider, sessionId; optional: label, projectId]
- karea_list_sessions - List AI coding sessions linked to a task (provider, sessionId, label, last active, resume command). [required: task; optional: projectId]
- karea_unlink_session - Remove a previously-linked AI session from a task. [required: task, sessionRowId; optional: projectId]

For the full parameter schema of any action, call karea_help with that action name.
- **karea_assistant** — Ask Karea a natural-language question about your work, or generate a recap of a period.

Pass one of these as `action`, with its arguments in `params`:
- 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. [required: message; optional: projectId]
- karea_recap - Return a summary of recent activity (tasks created, closed and updated) over a recent time window. [optional: hours, projectId]

For the full parameter schema of any action, call karea_help with that action name.
- **karea_help** — Return the full JSON Schema and description of any Karea action, so you can call it correctly through its group tool. Read-only; changes nothing. Omit `action` to list every available action grouped by tool.

## 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": ""
    }
  }
}
```

**Requires environment variables:** `KAREA_API_KEY` — 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 does

starecz/karea-mcp exposes Karea work-management data through MCP. It is organized into nine grouped tools covering read operations, task writes, notes, project changes, meetings, resources, assistant requests, deletion, and action help. Together, the groups provide 70 actions for managing development work and the information attached to it.

Tasks are the central workflow. Agents can find and inspect tasks, create or edit them, apply the same change to multiple tasks, close work, record completed work, or create an in-progress task. Tasks can include categories, priorities, deadlines, descriptions, tags, notes, closing requisites, subtasks, Jira issue keys, resources, and AI coding-session references.

The server also handles supporting project information. It can create and share projects, manage categories, maintain sticky notes, store task markdown, preserve titled AI context entries across sessions, track open questions, manage resources and meetings, schedule reminders, and produce an activity recap. The assistant action accepts a natural-language request that may read or modify Karea tasks.

## How it works

Install and run the package as an MCP process. The client invokes one of the grouped tools with an `action` and a `params` object; for example, task actions are sent through the task-writing group rather than registered as separate MCP tools by default. `karea_help` returns the full JSON schema and description for a named action, or lists the available actions when no action is supplied.

Read operations generally require a useful filter. Task, question, meeting, resource, and sticky-note list actions reject unfiltered requests and return the accepted filters so an agent can retry. Project listing and pending-reminder checks are exceptions. Actions that identify tasks accept visual IDs, names, or UUIDs where supported.

## Setup and configuration

Run the package with:

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

Set `KAREA_API_KEY` to an API key from Karea's API-key settings. `KAREA_URL` can point the server at the Karea service URL; the Claude Code example sets it to `https://karea.app`.

For Claude Code, register the server in `~/.claude.json` or use `claude mcp add`. For Cursor, place the MCP definition in `.cursor/mcp.json` within a project or in the global `~/.cursor/mcp.json`. Both configurations launch `npx` with the `-y` flag and package name `karea-mcp`.

The optional `KAREA_MCP_LEGACY_TOOLS=1` setting restores registration of the individual actions as separate tools instead of the grouped tool layout.

## Tools and capabilities

- Read projects, tasks, subtasks, notes, sticky notes, task markdown, AI context, questions, resources, meetings, reminders, Jira links, coding sessions, and recaps.
- Create, edit, batch-update, close, delete, or quickly log tasks and subtasks.
- Add closing requisites and toggle them before completing a task.
- Write human-readable task notes, long-form markdown, and cross-session AI context.
- Create, update, upload, delete, and attach text or file resources.
- Link tasks to Jira issues, meetings, questions, and AI coding sessions.
- Create meetings, attach tasks or questions, and manage reminders.
- Ask Karea's assistant to act on task information using natural language.

Destructive operations can permanently remove projects, categories, tasks, notes, resources, meetings, and other records. Several of these actions require an explicit confirmation parameter.

## Limitations and notes

A single unfiltered list request is not accepted for most collections; provide at least one supported filter. The server's default interface groups actions, so callers must use the correct action name and parameter object. Task documents and AI context serve different purposes: markdown is the task's long-form document, while context stores titled AI working-memory entries covering the task's history.

The `karea_mark_reminder_done` action completes both the reminder and its underlying task. Deleting a category also deletes its tasks, and deleting a project removes its contained tasks, categories, notes, and history.

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