keka-mcp
A read-only Keka HR/PSA MCP server for querying and auto-paginating HR, timesheet, leave, holiday, balance, and expense/advance data over stdio.
Fetch timesheet entries org-wide or for a single project, with date, employee, and project filters; date ranges are capped at 60 days.
Fetch employees, projects, and clients to map IDs to readable names and client/customer details.
Fetch leave requests with optional employee/date filters; date ranges are capped at 60 days.
Fetch leave balances per employee and leave type.
Fetch holidays for a specific calendar or auto-combine all calendars, optionally filtered by year.
Fetch expense claims, per-employee expenses, expense categories, expense policies, and travel/cash advance requests.
All data fetching is read-only and auto-paginated internally;
pageSizeonly controls request chunk size up to 200.No write/POST endpoints, reporting logic, or analysis is included.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@keka-mcp Show my timesheet entries for last week"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
keka-mcp
A local MCP (Model Context Protocol) server that wraps Keka HR's PSA timesheet and HRIS APIs, read-only, over stdio. Runs in Docker on your machine and connects to Claude Desktop (or any MCP client) as a local stdio server.
This is scaffolding only: thirteen read-only tools, OAuth token handling, and pagination. No reporting/analysis logic and no write/POST endpoints - that's a later phase, driven by prompting Claude against this server.
Tools
Tool | Wraps | Notes |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
All thirteen auto-paginate internally (looping pageNumber until Keka reports no
more pages) and return the fully combined result set - the MCP client never
has to page itself. pageSize only controls the chunk size of each request
to Keka (capped at 200); it does not limit the total number of results returned.
Related MCP server: HRIS MCP Connector
Setup
cp .env.example .env
# edit .env with your real client_id / client_secret / api_key / base URL
npm install
npm run build
npm test # unit tests
npm start # run directly with Node, without DockerRequired environment variables
See .env.example for the full list and descriptions:
KEKA_CLIENT_ID,KEKA_CLIENT_SECRET,KEKA_API_KEY- from Keka's Global admin settings -> Integrations & Automations -> API access -> API key.KEKA_BASE_URL- your company's data API host, e.g.https://yourcompany.keka.com.KEKA_TOKEN_URL- Keka's OAuth login host, e.g.https://login.keka.com/connect/tokenfor production orhttps://login.kekademo.com/connect/tokenfor the demo/sandbox environment. This is a different host fromKEKA_BASE_URLand isn't derivable from it - see "Open questions" below.
Missing any of these causes a clean fatal error at startup (by design - this is the one class of failure allowed to stop the process). Every other error (bad API response, network failure, an unhandled exception inside a tool handler) is caught and returned to the caller as a normal MCP tool error; the server process itself keeps running.
Auth
src/auth.ts implements Keka's API-key OAuth exchange
(docs):
POSTs
grant_type=kekaapi&scope=kekaapi&client_id=...&client_secret=...&api_key=...(form-urlencoded) toKEKA_TOKEN_URL.Caches the returned
access_tokenand its expiry in memory, refreshing ~60s before it actually expires.If a
refresh_tokencomes back, it's cached and used against the same token endpoint withgrant_type=refresh_token(docs) on renewal, instead of re-running the full API-key exchange. If the refresh call fails (e.g. the refresh token was revoked), it falls back to a full API-key exchange automatically. If norefresh_tokenis ever returned (Keka's documented example response for this grant type doesn't include one), the API-key exchange is simply re-run on expiry.TokenManager.getValidToken()is the single entry point every tool call goes through; concurrent calls during a refresh are coalesced into one outstanding token request.
Docker
Prebuilt image (recommended for users)
A public multi-arch image (Intel and Apple Silicon) is published to GitHub
Container Registry on every push to main:
docker pull ghcr.io/technogise/keka-mcp:latest
docker run --env-file .env ghcr.io/technogise/keka-mcp:latestNo clone, Node.js, or build is needed - just Docker and a .env file (copy
the contents of .env.example and fill in real values). Tags published:
latest- currentmainsha-<short-sha>- a specific commit, for pinning<version>(e.g.1.2.0) - when av1.2.0git tag is pushed
Publishing is done by .github/workflows/docker-publish.yml, which runs the
unit tests first and only pushes if they pass.
Building locally (for development)
docker build -t keka-mcp .
docker run --env-file .env keka-mcpSingle-stage, pinned base image (node:22.12.0-bookworm-slim), TypeScript
compiled at build time, npm prune --omit=dev after the build so no
dev-only dependencies ship in the final image, no secrets baked in (.env
is excluded via .dockerignore - only --env-file at docker run time
supplies credentials).
Important: docker run --env-file .env keka-mcp (no -i) is fine as a
smoke test - it starts, connects to stdio, logs its ready message, and exits
cleanly when stdin closes. But an actual MCP client (Claude Desktop
included) needs -i so Docker attaches the container's stdin/stdout to the
client's pipes - without it, Docker never forwards stdio and the client
can't talk to the server at all. See the Claude Desktop config below.
Claude Desktop configuration
Add to claude_desktop_config.json:
{
"mcpServers": {
"keka": {
"command": "docker",
"args": [
"run", "--rm", "-i", "--pull=always",
"--env-file", "/absolute/path/to/keka-mcp/.env",
"ghcr.io/technogise/keka-mcp:latest"
]
}
}
}Restart Claude Desktop after editing the config. Use an absolute path to
.env since Claude Desktop does not run this command from the project
directory. --pull=always picks up the latest published image on each
start; drop it (or pin a sha-... tag) if you want a fixed version, or
replace the image with keka-mcp to use a locally built one.
ChatGPT desktop (Codex) configuration
ChatGPT on the web can't reach a local stdio server; use the ChatGPT desktop
app. Either add a STDIO server under Settings -> MCP servers with
command docker and the same args as above, or add to
~/.codex/config.toml:
[mcp_servers.keka]
command = "docker"
args = ["run", "--rm", "-i", "--pull=always", "--env-file", "/absolute/path/to/keka-mcp/.env", "ghcr.io/technogise/keka-mcp:latest"]Testing
npm testUnit tests (src/__tests__/, vitest) cover, with no network/Docker
involved:
Pagination (
pagination.test.ts) - a mocked 3-page response combines correctly into one result set, a single-page response doesn't over-fetch, and an empty page stops the loop even iftotalPagesimplies more. The same three cases are repeated againstClient-,LeaveRequest-,Holiday-, andEmployeeLeaveBalance-shaped rows (the shapesget_clients,get_leaves,get_holidays, andget_leavebalanceuse) to cover those tools' pagination specifically, since they go through the exact samepaginateAllhelper as every other tool.Date-range validation (
dateRange.test.ts) - accepts ranges up to and includingMAX_DATE_RANGE_DAYS(60), rejects longer ranges with a message naming the limit and the dates given, rejectsfromafterto, and skips validation when either side is omitted (matching Keka's own default-window behavior). Also covers the 90-dayEXPENSE_MAX_DATE_RANGE_DAYSlimit at the exact boundary confirmed live (90 days accepted, 91 rejected).Expense tool handlers (
expenses.test.ts) - unlike the tests above, these drive the five expense tools through a real MCP client/server pair over an in-memory transport, with only the Keka HTTP client mocked. They assert the exact path and query each tool sends (all filters, URL-encodedemployeeId,approvalStatus: 0not dropped as falsy, clampedpageSize), multi-page combining, raw statuses and string amounts preserved, schema rejections (missingemployeeId,pageSize> 200,approvalStatus> 6) and date-range rejections happening before any Keka call, and Keka errors becoming cleanisErrorresults. Each was checked against deliberately introduced bugs (dropping the 90-day limit, dropping a filter, treatingapprovalStatus: 0as falsy) to confirm the tests catch them.Token caching/expiry (
auth.test.ts) - reuses a cached token while valid, re-runs the API-key exchange on expiry when norefresh_tokenwas issued, uses the refresh endpoint instead when one was, and falls back to a full exchange if the refresh call itself fails.
scripts/mcp-smoke-test.mjs is a small standalone script (not part of the
shipped server) that drives the built Docker image as a real MCP client
over stdio - used for the manual verification below and reusable for future
smoke-testing. It's written specifically against placeholder/dummy
credentials (it asserts every data call comes back as a clean auth error) -
that's intentional, it's exercising the failure path. It is not the script
used for the real-sandbox run below.
Verified
Everything below was actually run in this environment, not assumed:
Unit tests:
npm test- 46/46 passing (pagination x15 - generic +get_clients-shaped +get_leaves-shaped +get_holidays-shaped +get_leavebalance-shaped, date-range x10, expense tool handlers x16, token caching/refresh x5).TypeScript build:
npm run buildcompletes with no errors.Docker build:
docker build -t keka-mcp .succeeds; final image has 0 known vulnerabilities afternpm prune --omit=dev(dev-only vulnerabilities invitest'sesbuild/vitechain do not ship in the image).Docker run / stays alive:
docker run --env-file .env keka-mcpwith a complete (dummy-valued).envstarts, logs its ready message, and exits 0 only when stdin closes - confirmed it does not crash or exit on its own while stdin stays open (docker psshowedUpduring a 5s window with stdin held open).Fatal startup path: running with required env vars missing produces a single clean
FATAL error during startuplog line naming the missing vars and exits 1, as designed - confirmed withKEKA_CLIENT_IDset alone.MCP protocol handshake, over the real Docker container, via
scripts/mcp-smoke-test.mjs(a real@modelcontextprotocol/sdkClientspawningdocker run --rm -i --env-file .env keka-mcp, exactly as Claude Desktop would):initializesucceeds andtools/listreturns exactly the 13 expected tools:get_timesheet_entries,get_project_time_entries,get_employees,get_projects,get_clients,get_leaves,get_holidays,get_leavebalance,get_expense_claims,get_employee_expenses,get_expense_categories,get_expense_policies,get_advance_requests.Calling all 13 tools with dummy credentials against
KEKA_TOKEN_URL=https://login.kekademo.com/connect/token: each returned a cleanisError: trueMCP result with messageKeka token request failed (HTTP 400): invalid_client- i.e. Keka's real login host was reached and gave a real OAuth rejection (not a network failure or a 404), and the server surfaced it cleanly instead of crashing or leaking a stack trace to the client.get_clients,get_leaves,get_holidays,get_leavebalanceand the five expense tools behave identically to the other four here - same auth flow viagetValidToken(), same error shape.Calling
get_timesheet_entrieswithfrom=2026-01-01, to=2026-12-01(334 days) returnedisError: truewith a message naming the limit and the dates given, without ever making a network call (the validation runs before the Keka client is touched). The smoke test script now asserts the message names the 60-day limit (updated to match the discovery below - it had been left asserting the original 90-day spec value, which no longer matched the code).get_employee_expenseswith a 91-day range is likewise rejected client-side naming the 90-day limit, while an exactly-90-day range passes validation and only fails on the dummy credentials.The container process was still alive and responsive after all 16 of the above calls, including the 16 induced failures - confirming a failed tool call does not take the process down.
Live sandbox run (real credentials, docker run --env-file .env keka-mcp via a real MCP client over stdio)
Once real values were in .env, I ran the tools end-to-end against the
real sandbox tenant (never printing the credential values themselves) -
five in the original run, get_leaves, get_holidays,
get_leavebalance and the five expense tools each added and verified in
later sessions:
Auth: real API-key exchange succeeded against
KEKA_TOKEN_URL, returned a token withexpires_in: 86400, norefresh_token(matches the documented response shape and the "no refresh token yet" you told me up front).get_timesheet_entries(from=2026-06-01, to=2026-06-15, no filters):isError: false, 958 records across 10 pages (default page size 100) - confirms pagination actually loops across a real multi-page dataset, not just the mocked unit test.get_project_time_entrieswith a real project ID pulled fromget_projects(NotificationHub,046a855d-cedf-4aa4-bb73-fd2e9053296a):isError: false, 31 entries, all correctly scoped to thatprojectId.get_projects:isError: false, 112 projects across 2 pages - a second confirmation of real multi-page pagination.get_employees: initiallyisError: truewith a real 403 from Keka ("You don't have privilege to access this resource.") - not a code bug, the API key lacked an HRIS/employees scope grant. After you added that privilege on the tenant, re-ran it:isError: false, 237 employees across 3 pages - a third confirmation of real multi-page pagination. (A later re-run for theget_clientsaddition below showed 238, i.e. one new employee was added to the tenant between sessions - not a bug.)get_clients(added for this task):isError: false, 47 clients. At the defaultpageSize=100all 47 fit on one page; re-ran withpageSize=10to force multi-page pagination and got the same 47 records combined correctly across 5 pages, matching page-by-page against the raw API response with no duplicates or drops - a fourth confirmation of real multi-page pagination.get_leaves(added later, wrapsGET /time/leaverequests):isError: falseon the first try, no extra privilege grant needed (unlikeget_employees) - 294 leave requests across 3 pages, a fifth confirmation of real multi-page pagination.get_holidays(added later, wrapsGET /time/holidayscalendar+GET /time/holidayscalendar/{calendarId}/holidays):isError: falseon the first try, no extra privilege grant needed - the tenant has exactly one calendar ("Holiday List"), and calling with nocalendarIdcorrectly auto-discovered it and returned 21 holidays forcalendarYear=2026in a single page, each tagged with the rightcalendarId/calendarName. Only one calendar meant this didn't exercise the multi-calendar combine path, but the per-calendar pagination is the samepaginateAllproven five times over already, and the calendar lookup call and the holidays call are each single, unremarkable GETs - the seventh tool proven end-to-end.get_leavebalance(added later, wrapsGET /time/leavebalance):isError: falseon the first try, no extra privilege grant needed - 243 employees' balances across 3 pages. Each row carries aleaveBalancearray per leave type; the real per-type ID field turned out to beleaveTypeId(notleaveTypeIdentifieras on leave requests), and Unpaid Leave comes back withannualQuota: -1(no fixed quota). Filtering by oneemployeeIds+ oneleaveTypeIdsvalue correctly narrowed the result to 1 employee with 1 leave type.Expense tools (added later; all 13 tools re-run live in the same session as a regression check, all
isError: falsewith data). No extra privilege grant needed for any of the five:get_expense_claims: 388 claims across 4 pages,count == totalRecords, no duplicates across pages;pageSize=50returned the same 388 over 8 pages.employeeIds(one and two comma-separated),expenseClaimIds, andlastModifiedeach returned exactly the subset that filtering the full list locally gives.get_employee_expenses: an 89-day window found a known expense from the claims data; no range works (Keka applies a short default window); 91 days is rejected client-side. An unknown employee ID returns 0 rows, not an error - same as the other filters.get_expense_categories: all 19 categories; every one of the 12 distinctexpenseCategoryIds used on claims resolves to one.get_expense_policies: 1 policy (INR).get_advance_requests: all 10 requests;employeeIds,advanceRequestIds, andapprovalStatuseach matched local filtering, andapprovalStatus=0(no such rows) returned 0 - i.e. the filter is really applied, not silently ignored.
Invalid-input handling:
Out-of-range dates (
from=2026-01-01, to=2026-12-01, 334 days):isError: truewith the 90-day message, and (confirmed via the tool call being logged before any Keka request would appear) rejected client-side without ever calling the API.A bad/nonexistent
employeeIdsvalue: not an error - Keka treats it as a filter that matches nothing and returnstotalRecords: 0rather than a 4xx. That's Keka's own behavior (same as an unknownprojectId, which also just returns 0 rows), not something this server should override.
Process resilience: the container stayed alive and kept answering correctly through all of the above, including the two induced failures.
Partially open: every one of the 958 timesheet entries pulled in that
window had status: 2. That's consistent with 2 = Approved (the mapping
this code assumes) but doesn't exercise the other five values - I have not
seen a real 0/1/3/4/5 entry to confirm the full ordering. Still flagging
this per "Open questions" below rather than calling it verified.
Discovery: the real date-range limit is 60 days, not 90
While probing for entries with a non-Approved status, a 90-day-wide
request (from=2025-12-01, to=2026-02-28) came back from Keka itself with
HTTP 400: "Total days should not exceed more than 60 days" - not a rate
limit, not our own validation (a genuine content error from the API). That
contradicts both the task spec and Keka's own public API reference, both of
which say 90. MAX_DATE_RANGE_DAYS was changed to 60 to match what the
live sandbox actually enforces (unit tests and tool descriptions updated to
match, Docker image rebuilt) - you confirmed this rather than keeping the
spec's original 90. If a different tenant/plan really does get 90 days,
that's the one constant to change back.
Discovery: expense endpoints
Statuses have no published labels. Keka's reference only gives integer ranges: claim/advance
approvalStatus0-6,paymentStatus0-2, per-advancestatus0-4. Live distribution on claims:approvalStatus2/3/4/5 andpaymentStatus0/1/2. Passed through raw, likeget_leaves'sstatus.amountis a string with the currency attached ("3700.00 INR"), not a number - kept raw so the currency isn't lost.GET /expense/employees/expenses(the variant without an ID in the path) returns 400 "Employee ID is required", so only the/{employeeId}/expensesform is wrapped./expense/employees/{employeeId}/expensesallows 90 days, unlike the 60 days enforced on the timesheet endpoints: 2026-01-01..2026-04-01 accepted, ..2026-04-02 rejected with "Total days should not exceed more than 90 days".GET /payroll/employees/componentclaims(claims against reimbursable salary components) returned 403 "You don't have privilege to access this resource" for this API key, so no tool wraps it. Adding one needs the Payroll privilege granted to the API key first, as happened forget_employees.
Discovery: how a project maps to its client
Checked the real response shape of get_projects against the sandbox
specifically to confirm this: each project object has a flat, top-level
clientId field (a plain UUID string) - not a nested client.id or a
client object. Example from the live sandbox:
// GET /api/v1/psa/projects
{ "id": "046a855d-...", "name": "NotificationHub", "clientId": "c0a7cc1a-be9b-4211-8b93-0cc1b004158a", ... }That clientId is exactly the id field on the corresponding object
returned by get_clients:
// GET /api/v1/psa/clients
{ "id": "c0a7cc1a-be9b-4211-8b93-0cc1b004158a", "name": "Technogise", "billingName": "Technogise", "code": "Technogise", ... }Confirmed by fetching all 47 clients from the live sandbox and looking up
NotificationHub's clientId (c0a7cc1a-...) by exact match against each
client's id - it resolved to a real client ("Technogise"), not a miss.
So the mapping for reporting is simply project.clientId === client.id,
no nesting or extra lookup involved. get_clients objects also carry
billingName, code, description, billingAddress, and
clientContacts beyond the bare name, in case those are useful later.
Discovery: Keka enforces a 50 API-calls/minute quota
Repeated testing (pulling the 958-entry / 10-page dataset, the 112-project
/ 2-page dataset, the 237-employee / 3-page dataset, plus several probe
calls) tripped Keka's own rate limiter: "API calls quota exceeded! maximum admitted 50 per 1m." This surfaces cleanly as an isError: true result
(KekaApiError, labeled "Rate limited by Keka - back off and retry
later") rather than a crash, so no code change was needed here - but it's
worth knowing for the next phase: a single get_timesheet_entries call
over a wide range can itself cost 5-10+ underlying HTTP calls once
pagination kicks in, so a handful of broad tool calls in quick succession
can exhaust the budget for the rest of that minute (and in this session,
the quota stayed exhausted for several minutes rather than clearing after
60s, so the reset window may be longer than 1 minute in practice, or the
quota may be shared with other integrations on the same tenant). Nothing to
fix now, since it's out of scope for this task, but the reporting/analysis
phase should batch and pace its calls with this in mind.
Open questions for you (flagging rather than guessing)
statusfield shape mismatch: the task describedget_timesheet_entries's per-entrystatusas a string enum (UnSubmitted,Submitted,Approved,Rejected,InApprovalProcess,Invoiced). Keka's own API reference for/psa/timeentriesdocumentsstatusas an integer, 0-5, with no explicit label mapping given. The code preserves the raw integer from the API unmodified (as required) and adds astatusLabelfield using the order you listed (0=UnSubmitted ... 5=Invoiced) as a best-effort guess. The live sandbox run confirmed2 → Approvedis at least plausible (958/958 entries in the tested window werestatus: 2, all approved-looking data), but every entry pulled had the same value, so the other five haven't been seen in practice. Confirm the full ordering with Keka (or point me at an entry with a different status) before relying onstatusLabel.KEKA_TOKEN_URLis a new required env var, not in your original list. Keka's docs show the OAuth token endpoint lives on a separatelogin.*host (e.g.login.keka.com,login.kekademo.com) from the company data API host inKEKA_BASE_URL- there's no way to derive one from the other, so it's a separate, explicit setting. Resolved: your sandbox uses the value now in.env, confirmed working against the live token exchange.get_employees403 - resolved. It was an HRIS/employees scope missing on the API key; you granted the privilege on the tenant and a re-run confirmed 237 employees across 3 pages. No code change was needed.get_leaves'sstatusfield (0-4) has no label mapping at all - unlike timesheet status, you never gave an expected enum for leave requests, and Keka's own reference doesn't publish one either ("specific meanings not provided"). UnliketimeEntries.ts,leaves.tsdeliberately does not add a guessedstatusLabel- the raw integer is passed through as-is. If you know the mapping (something like Pending/Approved/Rejected/Cancelled plus one more), let me know and I'll add it the same way.
Project structure
keka-mcp/
src/
auth.ts # OAuth token fetch + refresh (TokenManager)
dateRange.ts # date-range validation (timesheet, leave and expense tools)
kekaClient.ts # HTTP wrapper: base URL, auth header, pagination helper
tools/
helpers.ts # shared error handling / logging / JSON result wrapper
timeEntries.ts # get_timesheet_entries, get_project_time_entries
employees.ts # get_employees
projects.ts # get_projects
clients.ts # get_clients
leaves.ts # get_leaves
holidays.ts # get_holidays
leaveBalances.ts # get_leavebalance
expenses.ts # get_expense_claims, get_employee_expenses,
# get_expense_categories, get_expense_policies,
# get_advance_requests
index.ts # MCP server entrypoint, registers all tools
__tests__/ # vitest unit tests
scripts/
mcp-smoke-test.mjs # manual end-to-end stdio smoke test (see "Verified")
Dockerfile
.env.example
package.json
tsconfig.jsonAvailable Tools
7 toolsget_clientsGet clientsA
Fetch all PSA clients (customers) from Keka. Automatically pages through the entire result set and returns it combined. Use this to map a project's clientId (from get_projects) to a readable client/customer name for reporting.
Inputs: pageSize.
get_employeesGet employeesA
Fetch all employees from Keka HRIS. Automatically pages through the entire result set and returns it combined. Use this to map employee IDs found in timesheet data to names, job titles, and employment status.
Inputs: pageSize.
get_holidaysGet holidaysA
Fetch holidays from Keka's holiday calendar(s). Keka scopes holidays per calendar rather than org-wide, so if 'calendarId' is omitted this tool first looks up every holiday calendar and then fetches and combines holidays from all of them (most tenants only have one). Each returned holiday is tagged with the calendarId/calendarName it came from. Automatically pages through every result set involved and returns it combined.
Inputs: pageSize, calendarId, calendarYear.
get_leavesGet leave requestsA
Fetch leave requests across the organization from Keka for a date range. Automatically pages through the entire result set and returns it combined. The 'from'..'to' range cannot exceed 60 days (validated before calling Keka; defaults to the last 30 days if both are omitted). Each request's numeric status field (0-4) is preserved as returned by the API - Keka's docs don't publish a label mapping for it, so no guessed label is added (unlike timesheet status).
Inputs: to, from, pageSize, employeeIds.
get_projectsGet projectsA
Fetch all PSA projects from Keka. Automatically pages through the entire result set and returns it combined. Use this to map project IDs found in timesheet data to project names.
Inputs: pageSize.
get_project_time_entriesGet project timesheet entriesA
Fetch PSA timesheet entries for a single project from Keka. Automatically pages through the entire result set and returns it combined. The 'from'..'to' range cannot exceed 60 days (validated before calling Keka).
Inputs: projectId (required), to, from, pageSize, +1 more.
get_timesheet_entriesGet timesheet entriesA
Fetch PSA timesheet entries from Keka across employees/projects for a date range. Automatically pages through the entire result set and returns it combined - callers never need to loop on pageNumber themselves. The 'from'..'to' range cannot exceed 60 days (validated before calling Keka). Each entry's numeric status field is preserved as returned by the API, with a best-effort statusLabel (UnSubmitted/Submitted/Approved/Rejected/InApprovalProcess/Invoiced) added alongside it.
Inputs: to, from, pageSize, projectIds, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 7 tools
Each tool targets a distinct resource (timesheet entries, project time entries, employees, projects, clients, leaves, holidays). The two timesheet tools could be confused since both fetch timesheet entries, but the descriptions clearly distinguish by scope (all vs. single project).
All tools follow a consistent get_<resource> pattern with snake_case, making the set predictable and easy to navigate. The naming convention is uniform across all seven tools.
Seven tools is well-scoped for a Keka integration covering PSA and HRIS data. Each tool serves a distinct data-fetching purpose, and the count feels appropriate for the server's apparent read-only reporting scope.
The server covers the main read-only data needs (timesheets, projects, clients, employees, leaves, holidays) but lacks write operations and some potentially useful lookups like individual employee details or project-specific leaves. For a reporting-focused server this is reasonable, but there are notable gaps if broader HRIS/PSA workflows are expected.
Related MCP Connectors
Query your org's data in natural language — read-only MCP access to SQL, NoSQL, files & warehouses.
MCP server for Talenta — read employee, attendance, leave, payroll and recruitment data.
MCP server exposing klokin time-tracking operations (employees, time entries, stores) to AI clients.
Connects AI assistants to TrackingTime for querying time entries, projects, tasks, customers, and team data using natural language.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceIntegrates with Keka HR platform to manage employee profiles, attendance, leave applications, payslips, and holidays through OAuth2-authenticated API tools.1ISC
- FlicenseNot gradedqualityDmaintenanceEnables querying HR data like recent hires, employee details, departments, and PTO balances through natural language in an MCP client.-
- AlicenseNot gradedqualityDmaintenanceEnables managing freee HR operations like employee data, attendance, leave, and approvals through natural language in MCP-compatible clients such as Claude Desktop.1ISC
- FlicenseNot gradedqualityDmaintenanceEnables natural-language-based employee leave management including leave balance checks, leave applications, approvals, and history retrieval through an MCP-compatible client.-