All posts
Developer tracking7 min read

Developer metrics in your data warehouse: one key, two MCP calls

For a data team: how to load per-developer statistics into a warehouse or a BI tool with a Data tool key. The request and its header, stats_schema then stats_query, the row limit, the cursor, and what to reread on each pass, shown as the trace of a call.

The DeployIt Team

We build DeployIt, an MCP server that lets a whole company ask its code from Claude and track each developer's work.

To get developer metrics into a data warehouse, DeployIt gives the machine a profile of its own: an administrator creates a Data tool key, dpk_…; your job sends it in a header, calls stats_schema then stats_query, and follows the cursor to read every row. The key reads the statistics in bulk. It opens no question about the code.

This page is for the data team that has been asked to put each developer's work next to the company's other figures. It follows one load from the first request to the last page, as the trace of a call.

What does a person read in Claude, and what does the warehouse read?

The same facts. Here is the person.

In your Claude · example

Give me October's report, developer by developer.

Here is October, developer by developer. The code score is read with the number of commits it covers.

DeveloperCommits shippedReviewedTestedCode score
Camille R.4671%52%3.9
Idriss B.3860%31%3.2
Léa M.3566%40%4.1
Drawn from your commits119 merged commits · sample data

Someone with the Leadership profile asks. Claude makes two tool calls, stats_schema then stats_query, and composes the table. A warehouse makes the same two calls, with no person and no Claude.

DeployIt has no dashboard and sends no report by email. If you want these figures on your own charts, this is the route.

How do developer metrics reach the data warehouse?

In four steps. The code blocks are the trace of the calls; their values are examples.

1. Present the key

POST https://mcp.deployit.ai/acme
Authorization: Bearer dpk_…

A warehouse or a BI tool does not sign up. It presents a Data tool key, created by an administrator and shown only once, in a header. acme stands for your company.

The body of each request is an MCP message. The protocol's specification says a client sends every JSON-RPC message as an HTTP POST, with an Accept header that lists application/json and text/event-stream, and that a session begins with an initialization exchange (modelcontextprotocol.io, checked on 17 November 2026). An MCP client library handles that part. The two calls that matter come next.

2. Read the contract: stats_schema

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": { "name": "stats_schema", "arguments": {} }
}

It takes nothing. It returns the statistics datasets, the definition of each measure, and when they were last computed. For the columns of each dataset and for the limits, it is the reference: build your mapping from its answer, not from an article.

The datasets, as the documentation lists them:

DatasetOne row is
commitsA merged commit: its author, when it landed, its PR, its tests, its ticket, its module, its score and its five criteria
pull_requestsA PR: who opened it, who reviewed it, how long it took
reviewsA review: who reviewed which PR, and the verdict
defectsA defect: the commit it came from, its fix, who fixed it, “confirmed” or “to confirm”
peopleA tracked person, or a coding agent
absencesAn absence period declared for a person
repositoriesA repository covered, its landing branch, when it was last computed
module_ownershipWho wrote each module over the last 12 months
person_period, team_periodSummaries by developer and by team, by month, quarter, half-year or year

3. Ask for rows: stats_query

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "stats_query",
    "arguments": {
      "dataset": "commits",
      "period": { "unit": "month", "value": "2026-10" },
      "limit": 5000
    }
  }
}

A query is a structured request: a dataset, a period, filters, groupings, measures, a limit. It is never free SQL. The SQL is yours, afterwards, in your own warehouse.

The same tool can aggregate instead of listing. Its arguments then name filters, groupings and measures:

{
  "dataset": "commits",
  "period": { "unit": "quarter", "value": "2026-Q3" },
  "filters": [{ "field": "repository", "op": "eq", "value": "acme/billing" }],
  "group_by": ["person"],
  "measures": ["commits", "code_note"]
}

When you ask for the code score, keep the number of commits it covers in the next column. The score is an average. It is never read alone.

4. Read the answer, follow the cursor

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "structuredContent": {
      "dataset": "commits",
      "rows": [{ "…": "one object per merged commit" }],
      "next_cursor": "eyJ2IjoxLCJoIjoi…",
      "computed_at": "2026-11-17T02:12:44Z"
    }
  }
}

This answer is abridged. A statistics query returns at most 5,000 rows (500 for the Leadership profile) and answers within 10 seconds; beyond that, follow the cursor or split by period. Following the cursor means sending the same request again, with the cursor you received:

{
  "dataset": "commits",
  "period": { "unit": "month", "value": "2026-10" },
  "limit": 5000,
  "cursor": "eyJ2IjoxLCJoIjoi…"
}

Stop when no cursor comes back. A Data tool key can make 600 calls a minute. These figures are in the limits of the documentation, and the key is described under connecting a data tool.

How often should the load run, and what must it reread?

The statistics are facts written once per merged commit, and they are updated every night. One load a day is enough. What you reload matters more than how often.

What the documentation saysWhat it means for your load
A commit can change afterwards: a defect shows up within 60 daysReread at least the last 60 days on each pass; upsert on the commit, do not append
A closed period can still move: a commit that landed late, two identities merged, a defect dismissedDo not freeze a closed month; keep the time each summary was last computed
A commit dated earlier but merged this month counts for this monthDate your facts by arrival on the landing branch, not by authoring date
Bots are excluded; detected coding agents are counted separately; an undeclared agent counts as human workKeep people and agents apart in your models
The code score is an averageStore the number of commits it covers beside it

Why a defect needs those 60 days, and what “to confirm” means until someone rules on it, is explained in how a fix finds the commit it repairs. The reading rules themselves are in the statistics section of the documentation.

What can a Data tool key not do?

  • Ask about the code. ask_code and recent_changes are for people: the Everyone, Developers and Leadership profiles. The key is for stats_schema and stats_query.
  • Write. None of the tools changes your repositories or your settings, and every call is written to your company's log.
  • Wait to be pushed. DeployIt sends no report by email and no outgoing webhook. Your job pulls.
  • Work without a plan. Without a plan or the trial, a Data tool key gets a refusal. Statistics are kept 24 months by default (12, 24, or as long as the company exists): if you plan to stop, export while the plan or the trial still runs.

One thing the key does carry: names. The statistics hold each developer's name and the detail of their work, modules and paths included. The tables you load are personal data about the people your company tracks.

Give them the audience you would give the Leadership profile; the privacy page tells tracked developers that the data tool their employer connects reads their statistics. Treat the key itself as a secret: it is shown once.

If nobody needs a chart, the same facts come as a table in Claude: see the monthly developer report, or which modules depend on one developer.

What DeployIt does here

DeployIt is an MCP server. Your company gets one link, https://mcp.deployit.ai/<company>/<code>; each person adds it to Claude (on the web, on the desktop or in Claude Code) and signs up with a name and an email, which is not verified; their questions are logged under that name. Everyone starts with the Everyone profile: questions about the product, answered from the code; a filter removes the code, the file paths and the names of team members it recognises from the answers, without proving their absence, and a leak test tells you what still gets through. An administrator gives the Developers profile (excerpts) or the Leadership profile (developer statistics) to whoever needs it. Repositories are connected from GitHub or GitLab; DeployIt makes no commit, branch or pull request, and only adds one webhook per repository.

A working copy of the code is kept while a repository is connected, hosted by DigitalOcean in London (UK); at indexing, each source file is sent to the model to be summarised, then the passages needed for an answer and the diffs of the commits that are scored; OpenAI's models by default, or the provider whose key you bring.

The four profiles and the rest of the product are in what DeployIt does, on one page.

Next step: during the trial, ask an administrator to create a Data tool key, call stats_schema, and load one month of commits into a scratch table: enough to see whether the grain fits your models.

Price. Free plan: 15 questions a week for the whole company. A 30-day trial, no card. Plans from €290 a month excluding tax for up to 25 tracked developers: see pricing.

Ask your code from Claude

30-day trial, no card. Or try the demo first: add https://mcp.deployit.ai/demo to your Claude connectors.

Connect my code

Frequently asked questions

How do I get developer metrics into a data warehouse?

With DeployIt, an administrator creates a Data tool key, shown only once. Your job presents it in a header, calls the stats_schema tool to read the datasets and their definitions, then stats_query to read the rows, following the cursor until none comes back. The key reads statistics in bulk and opens no question about the code.

Can I query developer statistics with SQL?

Not on the DeployIt side: stats_query is a structured request made of a dataset, a period, filters, groupings, measures and a limit, never free SQL. Once the rows are in your warehouse, the SQL is yours. The stats_schema tool is the reference for the columns and measures you can ask for.

How many rows does one statistics query return?

At most 5,000 rows with a Data tool key (500 for the Leadership profile), and it answers within 10 seconds. Beyond that, follow the cursor or split the request by period. A Data tool key can make 600 calls a minute.

How often should a warehouse reload developer statistics?

The statistics are updated every night, so one load a day is enough. Reread at least the last 60 days on each pass: a commit can change afterwards, because a defect shows up within 60 days. A closed period can still move too, and every summary carries the time it was last computed.

Can a Data tool key read the source code?

The key opens no question about the code: it is for the statistics tools, not for ask_code. The statistics do carry detail, including developers' names, modules and paths, so the tables you load are personal data about the people your company tracks. An administrator creates the key, and it is shown only once.

Continue reading

Connect my code