> ## Documentation Index
> Fetch the complete documentation index at: https://developers.projectcor.com/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP Server

> Connect any MCP-compatible AI client to your COR workspace using natural language

The COR MCP Server lets you interact with your COR workspace from any MCP-compatible AI client. Connect natively in Claude, Cursor, Windsurf, and other MCP clients to manage projects and tasks, log hours, communicate with your team, and get real-time insights — without leaving your AI assistant.

The server follows the [MCP specification (2025-11-25)](https://modelcontextprotocol.io/specification/2025-11-25) and uses **Streamable HTTP transport** with **OAuth 2.0** authentication.

<Info>
  **Endpoint:** `https://mcp.projectcor.com/mcp`
</Info>

**What you can do:**

* Ask about your pending tasks and get an instant overview
* Create and update projects and tasks with full detail
* Log worked hours on tasks for yourself or your team
* Post messages and @mention teammates directly in task threads
* Browse team members, clients, and project statuses
* Assign labels, collaborators, and attachments to tasks
* Get direct links to any project, task, or client in COR

***

## Features

<AccordionGroup>
  <Accordion title="Project Management">
    * **List projects** with filters by name, client, project manager, status, health, work order, and date range
    * **Get project details** including budget, profitability, logged hours, and billing info
    * **Create projects** with name, client, PM, estimated time, dates, and billing settings
    * **Update projects** — change status, archive, reassign PM, update budget
  </Accordion>

  <Accordion title="Task Management">
    * **Search tasks** across your organization with powerful filters: project, client, status, text search, date ranges, labels, and archived state
    * **Get my pending tasks** — instant view of all active tasks assigned to you
    * **Get task details** including description, collaborators, subtask hierarchy, and attachments count
    * **Create tasks** with title, project, description (HTML), deadline, priority, estimated hours, and subtask nesting
    * **Update tasks** — change any field without affecting others (partial update)
    * **Manage collaborators** — view and assign team members to tasks
    * **Manage labels** — assign and remove labels/tags on tasks
  </Accordion>

  <Accordion title="Communication">
    * **Post messages** on task threads with support for @mentions — your AI assistant builds the proper mention markup automatically
  </Accordion>

  <Accordion title="Time Tracking">
    * **Log worked hours** on any task with date, duration, and optional description
    * **Search time entries** with filters by user, project, client, date range, and approval status — includes totals per query
  </Accordion>

  <Accordion title="Team">
    * **Get your profile** — name, email, role, position, and remaining hours
    * **List users** in your organization with optional filters
    * **Get user details** by ID — role, position, daily hours, labels
  </Accordion>

  <Accordion title="Attachments">
    * **Add attachments** to tasks from Google Drive, Dropbox, or OneDrive
    * **List attachments** for any task with file details and source
  </Accordion>

  <Accordion title="Reference">
    * **List available labels** by model (task, project, or user)
    * **Get direct URLs** to any task, project, or client — open in browser instantly
  </Accordion>
</AccordionGroup>

***

## Setup

The COR MCP Server supports **Streamable HTTP transport** and uses OAuth 2.0 with dynamic client registration for authentication. Connect any compatible MCP client using:

```
https://mcp.projectcor.com/mcp
```

For clients that do not support remote MCP natively, use [`mcp-remote`](https://github.com/geelen/mcp-remote) as a bridge.

<Tabs>
  <Tab title="Claude.ai">
    <Steps>
      <Step title="Visit claude.ai/connectors">
        Go to [claude.ai/connectors](https://claude.ai/connectors) and find **COR** in the directory.
      </Step>

      <Step title="Connect">
        Click **Connect**. You will be redirected to COR to log in and authorize access.
      </Step>

      <Step title="Done">
        Once authorized, COR will be available in your Claude workspace.

        <Check>
          COR appears as a connected integration in your Claude workspace.
        </Check>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Desktop">
    Add the following to your `claude_desktop_config.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "COR": {
          "name": "COR",
          "url": "https://mcp.projectcor.com/mcp",
          "headers": {}
        }
      }
    }
    ```

    Restart Claude Desktop. On first use you will be prompted to log in to COR and authorize the connector.
  </Tab>

  <Tab title="Claude Code">
    Run the following command:

    ```bash theme={null}
    claude mcp add --transport http cor https://mcp.projectcor.com/mcp
    ```

    Then run `/mcp` in a Claude Code session to go through the authentication flow.
  </Tab>

  <Tab title="Cursor">
    Add the following to your `.cursor/mcp.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "COR": {
          "url": "https://mcp.projectcor.com/mcp"
        }
      }
    }
    ```

    On first use, Cursor will open a browser window to complete OAuth authorization with COR.
  </Tab>

  <Tab title="VS Code">
    <Steps>
      <Step title="Add server via Command Palette">
        Open the Command Palette (`Ctrl/Cmd + P`) and search for **MCP: Add Server**, then select **Command (stdio)**.

        Enter the following command:

        ```
        npx mcp-remote https://mcp.projectcor.com/mcp
        ```

        Enter **COR** as the server name and press Enter.
      </Step>

      <Step title="Activate the server">
        Go to **MCP: List Servers** → select COR → **Start Server**.
      </Step>
    </Steps>

    Alternatively, add directly to your VS Code `settings.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "COR": {
          "command": "npx",
          "args": ["-y", "mcp-remote", "https://mcp.projectcor.com/mcp"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Windsurf">
    Open Windsurf settings (`Ctrl/Cmd + ,`) → scroll to **Cascade → MCP servers** → **Add Server → Add custom server**, then add:

    ```json theme={null}
    {
      "mcpServers": {
        "COR": {
          "command": "npx",
          "args": ["-y", "mcp-remote", "https://mcp.projectcor.com/mcp"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Zed">
    Open Zed settings (`Cmd + ,`) and add:

    ```json theme={null}
    {
      "context_servers": {
        "COR": {
          "source": "custom",
          "command": "npx",
          "args": ["-y", "mcp-remote", "https://mcp.projectcor.com/mcp"],
          "env": {}
        }
      }
    }
    ```
  </Tab>

  <Tab title="Others">
    Any MCP-compatible client can connect to COR using the following settings:

    | Setting        | Value                                                                                 |
    | -------------- | ------------------------------------------------------------------------------------- |
    | URL / Endpoint | `https://mcp.projectcor.com/mcp`                                                      |
    | Transport      | Streamable HTTP (native) or stdio via `npx mcp-remote https://mcp.projectcor.com/mcp` |
    | Authentication | OAuth 2.0 (handled automatically on first connection)                                 |
  </Tab>
</Tabs>

***

## Authentication

The COR MCP Server uses **OAuth 2.0 authorization code flow**. You will need:

* An active COR account at [cor.works](https://cor.works)
* Any role (Collaborator, Project Manager, Director, or C-Level)

<Steps>
  <Step title="Connect your MCP client">
    Your MCP client redirects you to COR's login page.
  </Step>

  <Step title="Log in">
    Log in with your COR credentials.
  </Step>

  <Step title="Authorize">
    COR asks you to authorize the server to access your workspace. Review the permissions and approve.
  </Step>

  <Step title="Done">
    After approving, you are redirected back to your AI client — fully connected.

    <Check>
      Your access token is stored securely in the server session. Tokens are refreshed automatically in the background. You only need to authorize once per client (Claude, Cursor, VS Code, etc.).
    </Check>
  </Step>
</Steps>

<Note>
  **Data access:** The server accesses your COR workspace on your behalf using your credentials. It can only perform actions that your COR role permits. No data is stored or shared outside of your COR account and the active session.
</Note>

***

## Examples

<AccordionGroup>
  <Accordion title="Check my pending tasks">
    **User prompt:**

    > "What are my pending tasks this week?"

    **What happens:**

    * The connector calls `cor_get_my_pending_tasks` filtered to active (non-archived), non-finished tasks assigned to you
    * Results are filtered to show tasks with a start or deadline in the current week
    * Returns task titles, statuses, priorities, deadlines, and project names

    **Expected output:**

    ```
    You have 5 pending tasks this week:

    1. [2019468] Add time tracking tools — High priority, due Mar 13, project: Integración Claude Connector
    2. [2018923] Review Q1 budget — Urgent, due Mar 14, project: Finance 2026
    3. [2018891] Design homepage mockup — Medium, in progress, project: Website Redesign
    ...
    ```
  </Accordion>

  <Accordion title="Create a task">
    **User prompt:**

    > "Create a task called 'Write release notes for v2.1' in the Product Updates project with high priority and deadline March 25"

    **What happens:**

    * The connector searches for the "Product Updates" project using `cor_list_projects`
    * Calls `cor_create_task` with the title, project ID, priority 2 (High), and deadline 2026-03-25
    * Returns confirmation with the new task ID and a direct link

    **Expected output:**

    ```
    Task created successfully:
    - ID: 2021045
    - Title: Write release notes for v2.1
    - Project: Product Updates
    - Priority: High
    - Deadline: 2026-03-25
    - Link: https://your-company.cor.works/tasks/2021045
    ```
  </Accordion>

  <Accordion title="Log worked hours">
    **User prompt:**

    > "Log 2.5 hours on the 'API Integration' task for today"

    **What happens:**

    * The connector searches for the task using `cor_list_tasks` with text search
    * Calls `cor_log_time` with task ID, duration 2.5 hours, and today's date
    * The entry is created with `origin: MCP_CONNECTOR` for traceability
    * Returns the time entry confirmation

    **Expected output:**

    ```
    Time logged successfully.

    - Entry ID: 88423
    - Task: API Integration (task 2018745)
    - Hours: 2.5h
    - Date: 2026-03-12
    - User: Daniel Guzman
    - Status: pending
    ```
  </Accordion>

  <Accordion title="Review project status and profitability">
    **User prompt:**

    > "Give me a summary of the Marketing Campaign 2026 project — status, health, and how we're doing on profitability"

    **What happens:**

    * The connector searches for the project using `cor_list_projects` with name filter
    * Calls `cor_get_project` to retrieve full details including budget, logged hours, and profitability metrics
    * Returns a structured summary

    **Expected output:**

    ```
    Project: Marketing Campaign 2026 [ID: 1752344]

    - Status: In Process
    - Health: At Risk
    - Client: Acme Corp
    - PM: Maria Lopez
    - Start: 2026-01-15 | End: 2026-04-30
    - Estimated hours: 240h | Logged hours: 198h
    - Profitability now: 42% | Estimated: 61%
    - Billable: Yes
    ```
  </Accordion>

  <Accordion title="Post a message and mention a teammate">
    **User prompt:**

    > "Post a message on the 'Budget Review' task saying the updated spreadsheet is ready for review, and mention Maria Lopez"

    **What happens:**

    * The connector searches for the task and looks up Maria Lopez's user details using `cor_list_users`
    * Calls `cor_post_task_message` with the message text and mention data
    * The message is posted with proper `@mention` markup so Maria receives a notification in COR

    **Expected output:**

    ```
    Message posted on task [2019234] Budget Review.

    "The updated spreadsheet is ready for review @Maria Lopez"

    Maria Lopez has been notified.
    ```
  </Accordion>
</AccordionGroup>

***

## Reference values

### Task status

| Value        | Meaning           |
| ------------ | ----------------- |
| `nueva`      | New (not started) |
| `en_proceso` | In progress       |
| `estancada`  | Stalled / blocked |
| `finalizada` | Completed         |

### Task priority

| Value | Label  |
| ----- | ------ |
| `0`   | Low    |
| `1`   | Medium |
| `2`   | High   |
| `3`   | Urgent |

### Project status

| Value        | Meaning   |
| ------------ | --------- |
| `in_process` | Active    |
| `finished`   | Completed |
| `suspended`  | On hold   |

### Project health

| Value | Label    |
| ----- | -------- |
| `1`   | On track |
| `2`   | At risk  |
| `3`   | Delayed  |
| `4`   | Critical |

***

## Support

<Note>
  For connector-specific issues, open a ticket via the [Help Center](https://cor.zendesk.com/) or email [help@projectcor.com](mailto:help@projectcor.com) with "MCP Connector" in the subject line.

  **Privacy Policy:** [projectcor.com/cor-privacy-and-personal-data](https://projectcor.com/cor-privacy-and-personal-data/) — The server accesses your COR workspace on your behalf and does not store, share, or sell your data outside of your COR account and the active session.
</Note>