io.penguin-statsPublished by penguin-stats.ioOfficial publisherv1.0.0Updated Oct 30, 2026
Crowdsourced Arknights drop rates by stage and item, for the CN, US, JP and KR game servers
Read-only MCP server for crowdsourced Arknights drop rates by stage and item across the CN, US, JP and KR game servers.
Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.
Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.
Read https://sourceweft.com/mcp/io.penguin-stats%2Fpenguin-stats/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.Add this to your client's mcpServers config.
{
"mcpServers": {
"penguin-statistics": {
"type": "http",
"url": "https://mcp.penguin-stats.io/mcp"
}
}
}[License] [Last Commit] [GitHub Actions Status] [go.mod Version] [FOSSA Status]
The re-designed Penguin Statistics v3 Backend, built with Go.
The drop data is public:
REST API at https://penguin-stats.io/PenguinStats/api/v2/: see the
developer docs and the
OpenAPI (Swagger 2.0) spec.
MCP server for AI assistants (Claude, ChatGPT, Cursor, VS Code, Cherry Studio and others) at
https://mcp.penguin-stats.io/mcp: Streamable HTTP, no authentication, read-only. In Claude Code:
The steps for every other app, in English and Chinese, are at https://mcp.penguin-stats.io/.
Plugin and skill for coding agents, the MCP server with a skill on reading, citing and querying the numbers: https://github.com/penguin-statistics/agent-skills
The drop data is licensed CC BY-NC 4.0: non-commercial use, with
credit. Credit it as Data: Penguin Statistics (penguin-stats.io), CC BY-NC 4.0. The code of this repository is
MIT.
This Go project mainly uses:
This project mainly follows a RESTful API design.
The report worker moves a report task out of the penguin-reports stream into penguin-reports-dead (subjects
REPORT_DEAD.*) when it can never be processed (it is not a task, or a stage of it does not exist) or when it failed at
each of its 30 deliveries, which take about 97 minutes of retry delays. Each move is logged at error level
(reportwkr.malformed, reportwkr.parked or reportwkr.dead). The copy keeps the payload as published, with these
headers:
Penguin-Original-Subject: the subject it was published under, like REPORT.SINGLEPenguin-Original-Sequence: its sequence in penguin-reportsPenguin-Deliveries: its deliveries when it movedPenguin-Last-Error: the error that moved itA task too close to the maximum payload to fit with these headers moves without them, and its subject under
REPORT_DEAD.* names its original subject; its move is logged as reportwkr.dead.bare, with the sequence and the error.
Nothing in the stream expires. With the nats CLI, once the cause is fixed:
A task that moved after failing at each delivery may have been stored by one of them whose commit outcome was unknown
(for example the connection dropped during the commit); check drop_reports for its account and time before replaying
it.
internal/workers/reportwkr/consumerbench_test.go (build tag consumerbench) drives the report consumer through its
real code path: each task is published to a JetStream stream of its own, fetched and handed to
Worker.ingestPreprocess (BenchmarkConsumer/ingest), which stores it in PostgreSQL and sets its recall key in Redis,
with logging and tracing configured as in production. BenchmarkConsumer/process runs Worker.process alone. Besides
wall time and allocations it reports, per task, the CPU time of the process (cpu-ns/op, user + system from
getrusage, which a shared machine disturbs far less than the wall time) and the time spent waiting on PostgreSQL
(pg-wait-ns/op, pg-wait-%) and Redis.
The tasks (internal/workers/reportwkr/testdata/consumerbench/tasks.jsonl.gz) are encoded as the report handler
publishes them, drawn from the stages, servers, times, sources, versions and drop patterns of recent production reports,
with synthetic accounts, IPs and task ids.
It needs a scratch database, Redis and NATS with JetStream. The scratch database holds the schema and the reference
tables of a restore of production (penguinprod, only read) and synthetic accounts; the benchmark truncates its
drop_reports and drop_report_extras:
The defaults point at penguin_cpubench on 127.0.0.1:5434, Redis DB 14 on 127.0.0.1:16379 and NATS on 127.0.0.1:4222
(CONSUMERBENCH_POSTGRES_DSN, CONSUMERBENCH_REDIS_URL, CONSUMERBENCH_NATS_URL). Then:
Outputs go to $OUT (default a new temporary directory). Each run logs the load average and the queries other sessions
had active on the cluster to $OUT/runs.log. The PostgreSQL connection runs over loopback, where a write system call
also does the receiving side's TCP work, so the system calls weigh more than against a remote server.
This project has mainly being maintained by the following contributors (in alphabetical order):
The full list of active contributors of the Penguin Statistics project can be found at the Team Members page of the website.
This project is made possible by the following contributors. Contributions are always welcome!
Source: README.md at commit 1898c26
Dataset info
Describes the Penguin Statistics drop data: what its numbers mean (times, quantity, drop rate, sanity per item, window), the game servers with their time zones and how fresh the data of each is, the caveats, the license and how to credit it. Call it when unsure how to read or cite the numbers.
Takes no parameters.
Item drop rates
Where to farm an item: ranks every stage of a game server that drops it, with sanity per item, drop rate (items per run), runs (times) and quantity. Use it for any question about where to get an item, its best or most efficient stage, or which of several stages to run for it: one call ranks every stage, so don't look stages up one by one with get_stage_drops (only a named stage left out of the top_n returned). By default the stages open now that still drop it, lowest sanity per item first; stages of fewer than 100 runs (lowSample) rank after the others, gachas and the recruitment (no sanity cost) last. sort_by=drop_rate ranks by rate instead; include_closed=true adds past events and ended drops. item_id takes the item's name in any language; search_items first only when the name may mean several items.
langtop_nserverrequireditem_idrequiredsort_byinclude_closedStage drops
What one stage drops on a game server: each item with drop rate (items per run), sanity per item, runs (times) and quantity, highest rate first, then the items it no longer drops; with the sanity cost of the stage and whether it is open now. For questions about a given stage. To find where to farm an item, call get_item_drop_rates instead: one call ranks every stage that drops it. Takes the stage ID from search_stages (codes are shared by several stages); a code works too if only one stage on the server has it.
langserverrequiredstage_idrequiredList events
Lists the events (limited-time activities) of a game server: status now (open, upcoming or closed), open and close times, whether a rerun. By default the open and upcoming events with their stage IDs (for get_stage_drops), or the latest 3 if there are none; open_only=false lists every event, latest first, with stage counts only. The main story and the permanent side stories are not events.
langlimitserverrequiredopen_onlySearch items
Finds items (materials, battle records, chips, furniture, event items) by name in any language (zh, en, ja, ko), by alias or nickname (土块, 狗粮), by pinyin (guyuanyan) or by item ID, and returns their item IDs (get_item_drop_rates takes a name too; search first when unsure which item is meant) and names in every language. Best matches first: exact before prefix before substring, names before aliases. Several items can share an alias (石头 is each tier of Orirock): ambiguous is then true; ask the user which one is meant or decide by context. Items of other types (workshop-crafted materials such as D32 Steel, recruitment tags) are returned only when no listed item matches, with a note saying what they are.
langlimitqueryrequiredSearch stages
Finds stages by code (1-7, S2-12, YW-4; full-width characters work too), by stage ID (main_01-07), or by the name or ID of their zone (第十章, Under Tides), and returns their stage IDs (for get_stage_drops; to find the stages that drop an item, use get_item_drop_rates) with their zone, sanity cost and whether they are open on the server now. Codes are not unique: the standard and tough versions of a stage of the main story share them, as do an event, its rerun and the stages it left open for good. Best matches first (the code before the zone, exact before prefix before substring), then the stages open now, standard before tough, original before permanent before rerun. ambiguous is true when several stages share the best-matching code (not for the stages of a zone found by its name): ask the user which one is meant or decide by context.
langlimitqueryrequiredserver100% of the applicable checks met
How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.
claude mcp add --transport http --scope user penguin-stats https://mcp.penguin-stats.io/mcp# list the tasks, with their headersnats stream view penguin-reports-dead# show one, by its sequence in penguin-reports-deadnats stream get penguin-reports-dead 42# replay it under its original subject: the worker processes it as a new tasknats stream get penguin-reports-dead 42 --json | jq -r .data | base64 -d \ | nats pub REPORT.SINGLE --force-stdin# remove it once replayednats stream rmm penguin-reports-dead 42 -fscripts/consumerbench/setup-db.sh # creates penguin_cpubench and the role cpubench on 127.0.0.1:5434# regenerate the tasks, if needed: CONSUMERBENCH_TASKS, CONSUMERBENCH_BATCH_PERMILLE, CONSUMERBENCH_SEEDCONSUMERBENCH_GENERATE=1 go test -tags consumerbench -run TestConsumerBenchGenerate ./internal/workers/reportwkr/# one rungo test -tags consumerbench -run '^$' -bench BenchmarkConsumer -benchtime 2000x ./internal/workers/reportwkr/# interleaved runs of variants, compared with benchstat: logging to a counting io.Discard (prod), to /dev/null# (devnull), disabled (logoff); tracing as in production at 10% (prod), off (traceoff), at 100% (trace1); both off (off)COUNT=10 scripts/consumerbench/run.sh bench prod logoff traceoff off devnull trace1# CPU and allocation profiles of the ingestion, the top functions and the share of each part of the consumerscripts/consumerbench/run.sh profile prod