List Repovive contests with their ObjectId, contest number, title, computed status (upcoming/ongoing/past), window, problem and member counts, and premium/rated flags. The ObjectId returned here is what every other contest tool needs.

Fetch one contest's full record by contest number (the number shown in its title) or by ObjectId. Pages through the contest list until it finds a match, so older contests resolve too.

List the contests the authenticated account is registered for, including virtual participation windows. Check this before registering again.

Register the authenticated account for a contest. Use mode='normal' for the live window, or mode='virtual' with an ISO-8601 virtual_start_time to schedule a virtual run. This is a real registration on the account.

Fetch the shareable invite link for a contest, when the authenticated account is allowed to invite. Use repovive_check_invite_eligibility first if unsure.

Report whether the authenticated account may issue contest invitations, and any remaining invite quota.

List which users hold editor/viewer/admin roles on a contest. Requires the authenticated account to administer that contest.

Grant a user a role on a contest (e.g. editor, viewer, admin). Resolve the target's user id with repovive_search_users first. Requires contest administration rights.

Revoke a user's role on a contest, removing their editor/viewer/admin access. Requires contest administration rights.

Update a contest's settings — title, lobby problem count, admin-only and weekly-challenge flags, problem display style, rated tier cap. Only the arguments you pass are changed. Requires contest administration rights.

Permanently delete a contest and everything attached to it. This cannot be undone — confirm with the user before calling. Requires contest administration rights.

Fetch a page of Repovive's global ratings leaderboard — rank, name, current and max rating, contest count and country — with optional country, name and tier filters.

Return the Repovive account this server is authenticated as: id, name, email, role, verification and premium status, Vive balance, streaks, country and join date. Use it to confirm which account submissions and messages will be attributed to.

Fetch the public profile of the authenticated account: username, full name, job role, organisation, open-to-work flag, location and verification badges. Complements repovive_whoami, which returns account/billing state instead.

Set the country shown on the authenticated account's profile and used for country-filtered leaderboards. Takes an ISO 3166-1 country code and overwrites any previous value.

Search Repovive users by name (partial match) and return the matches with their user ids. Use it to resolve a person's id before starting a direct message, blocking them, or granting contest permissions.

List the documents (CV/resume and other uploads) attached to the authenticated Repovive account, with their ids and metadata.

Return the deployed Repovive web-app build version. This is an unauthenticated health/diagnostic call — use it to check that the platform is reachable.

Invalidate the current Repovive session server-side and drop the cached token from this MCP server. The next authenticated tool call logs in again from the configured credentials; use it to force a fresh session.

Return an empty Repovive problem object plus a field-by-field description of the schema. Start here when authoring a problem by hand rather than from a generator.

List the built-in problem generators (kind, title, difficulty, tags) that repovive_generate_problem and repovive_build_contest accept. These produce classic single-test problems; see repovive_list_house_templates for Repovive's round format.

Generate a complete, self-consistent problem from a built-in generator: statement, constraints, samples with explanations, deterministic hidden tests, an input validator, an editorial and a reference solution. Test outputs are produced by running the reference solution on this host. Same seed gives the same problem.

Check a problem object against Repovive's schema and report every issue found: missing or empty fields, a non-URL-safe slug, bad difficulty, non-positive limits, and missing or malformed test cases. Run it before pushing a draft.

Run a solution against test cases on this host and return a per-case verdict (Accepted / Wrong Answer / Time Limit Exceeded / Memory Limit Exceeded / Runtime Error / Compilation Error) with the failing input, expected and actual output. Supply either problem_json or test_cases_json. Use this before repovive_submit_solution — it costs nothing and does not touch the platform. Executes the code you pass, so only judge code you trust.

List the languages the local judge can actually run on this host (toolchain present) alongside every language it knows about. Check this before repovive_judge_solution.

Generate a whole contest from an ordered list of generator kinds and verify it: each problem is schema-checked, its reference solution is judged against its own tests, and a known-wrong solution is checked to fail. Returns the import-ready contest plus a per-problem verification report; require verification.all_passed before using it.

List the house-style generators, each pre-assigned to a round slot (A-G) with the matching points and difficulty. These produce Repovive's published round format: multi-test input led by t, braced-array I/O sections, one sample holding several sub-cases. Feed the kinds to repovive_build_house_round.

Generate one problem in Repovive's published house style: multi-test input led by t, braced-array input/output sections, a bulleted constraints list bounding t, and a single sample packing several sub-cases with per-case explanations. Deterministic in the seed; runs the reference solution on this host to produce expected outputs.

Check a problem against Repovive's measured house style and list every deviation: input/output braced-array notation, the t bound in the constraints bullet list, tags from the fixed 12-word vocabulary, 256 MB memory, 1-2 s time limit, a points value on the ladder, and exactly one explained sample.

Build a full Repovive-format round from house-style generators, one per slot A-G, applying the 500-3500 points ladder and the easy/easy/medium/medium/medium/hard/hard difficulty curve. Every problem is schema-checked, house-style-checked and judged against its own tests; require verification.all_passed before publishing anything.

List the problem-draft build sessions owned by the authenticated account, with their session ids and current state. Every other build tool needs one of these ids.

Start a new problem draft on Repovive and return its session id. Drafts are private to the authoring account until explicitly attached to a contest. Set force_new=False to resume an existing draft with the same name instead of creating another.

Permanently delete a problem draft and everything in it — statement, test cases, solutions, generators. This cannot be undone; confirm with the user before calling.

Update a draft's metadata: slug, difficulty, time limit, memory limit and interactive flag. Only the arguments you pass are changed; the rest keep their current values.

Write the statement of a draft: title, description body, input/output formats, constraints, interaction protocol and tags (markdown with LaTeX). Only the arguments you pass are changed. Avoid an inline math span followed directly by a period — Repovive rejects $10^5$.

Send a raw update-sources body to a draft, for fields the typed tools do not cover. Prefer repovive_build_update_statement, _set_generator, _set_gen_data, _set_validator or _set_custom_checker unless you need something they omit.

Store a named test generator program in a draft. Generators are invoked from the gen-data script (repovive_build_set_gen_data) to produce the hidden tests.

Set a draft's gen-data script — one generator invocation per line, each producing one hidden test file. Define the generators first with repovive_build_set_generator.

Remove a named generator from a draft. Any gen-data lines that invoke it will stop working, so update the gen-data script too.

List the test cases currently stored in a draft, with the per-case ids needed by repovive_build_delete_testcase.

Append test cases to a draft in one call. Cases are ADDED to whatever is already there — clear first with repovive_build_clear_testcases if you mean to replace them. For interactive problems omit expectedOutput; the interactor decides the verdict.

Delete every manually added test case from a draft. This cannot be undone — use it before uploading a replacement set.

Delete one test case from a draft by its id. Get ids from repovive_build_list_testcases. This cannot be undone.

Fetch the solutions attached to a draft — the main test solution plus any alternatives with their expected verdicts.

Attach a solution to a draft with its expected verdict (AC, WA, TLE, …) and, by default, make it the draft's main test solution. Set replace=False to keep the existing alternatives and append — useful for adding deliberately wrong or slow solutions that the test data must reject.

Set a draft's editorial pages — the post-contest explanation shown with the problem. Pass a JSON list of {"title", "content"}; pass "[]" to clear them.

Attach an input validator to a draft. The validator reads each generated test and asserts it satisfies the stated constraints, catching malformed test data before the problem goes live.

Attach a custom checker to a draft, replacing exact output matching. Use it when a problem accepts multiple correct answers or needs tolerance-based comparison.

Kick off Repovive's build pipeline for a draft: run the generators, validate the inputs, and run the solutions against the produced tests. Poll repovive_build_run_status for the outcome.

Check the status of a draft's build run started by repovive_build_prepare_judge_target: progress, per-stage results and any errors.

Cancel the build run currently executing for a draft.

Write a problem object into an existing draft: metadata, statement and (optionally) test cases. Test cases are APPENDED to whatever the draft already holds. For a complete import that also clears old cases and uploads the reference solution, editorial and validator, use repovive_build_author_complete_problem.

Import a complete problem into a draft in one call: clears the existing test cases (unless replace_testcases=False), then writes metadata, statement, test cases, the reference solution, editorial pages and input validator. Returns a per-step report — check all_ok before treating the draft as ready. This edits a private draft; publishing it to a contest is a separate call.

List the contests the authenticated account may attach a finished draft to, with their ids. Feed one of these ids to repovive_build_add_to_contest.

Publish a draft by attaching it to a contest as a real problem. This is the step that makes authored work visible on the platform — never call it without the user's explicit approval. Verify the draft builds cleanly first.

List Repovive blog posts with title, slug, author, publication date, read time, likes/views and tags. Supports page/limit paging.

List the categories blog posts are filed under, with their slugs and post counts.

List Repovive courses visible to the authenticated account: id, title, slug, description, section/unit counts, access level, enrolment count and whether this account can edit them.

List the users who can edit a course, with their roles. Requires edit rights on that course.

Grant a person edit or view access to a course by their email address. Requires edit rights on that course.

Revoke a user's edit access to a course. Requires edit rights on that course; the removed editor loses access immediately.

Update a course's title and, optionally, its description and tags. Only the fields you pass are changed. Requires edit rights on that course.

Publish or unpublish a course platform-wide. Making a course public exposes it to every Repovive user, so confirm before calling. Requires site administration rights.

Browse this server's local log of state-changing calls, newest first: when, which access token, which tool, what it targeted, whether it succeeded, and the revision it produced. Filter by target, tool, actor, status or age. This is the audit trail — use repovive_list_revisions to see an entity's versions.

Fetch one history entry in full, including the (secret-redacted) arguments the tool was called with and any error it returned. Use it to see exactly what a change did.

List the saved versions of an entity, newest first, with the sequence number to pass to repovive_restore_revision. Revisions are captured automatically whenever a problem draft, contest, course or your profile is changed through this server.

Fetch one saved revision including its full snapshot — the statement, test cases, solutions and settings as they stood. Address it by revision id, or by target plus sequence number.

Compare two saved revisions of the same entity and list what changed field by field — added, removed and modified. Use it to see what a change actually did before deciding whether to roll it back.

Roll an entity back to a saved revision by re-applying its snapshot through the normal Repovive API. Nothing is deleted: the restore is itself recorded as a new revision, so you can undo the undo. Pass into_target_id to restore a snapshot into a different entity — for instance to rebuild a deleted problem draft in a fresh build session. Use dry_run=True first to see exactly which steps would run.

Step one change back: restore the entity's previous revision, undoing the most recent edit made through this server. Equivalent to restoring seq-1. Nothing is deleted — the undo is recorded as a new revision, so it can itself be undone. Use dry_run=True to see what would change first.

Report where the history database lives, whether recording is on, how much it holds, the retention limits in force, and which entity kinds can be rolled back.

Permanently delete history entries and revisions — everything older than N days, or everything for one entity. This destroys the ability to roll those changes back and cannot be undone; confirm with the user before calling.

Fetch the current price list for Repovive mock interviews, by interview type and duration.

Report whether Repovive currently has mock-interview capacity available for booking.

List the mock-interview sessions booked by the authenticated account, with their scheduling and status. Supports offset/limit paging.

List Repovive's curated practice sets (Classics, FAANG, Quant, Math) with their keys, submission kind (code/answer/proof) and browser URLs. Statements for these sets are website-only; for problems readable through this server use repovive_list_contests then repovive_list_contest_problems.

List every problem in one contest with its slug, order, difficulty, points, limits, tags and solve counts. Set full=True to also include statements. Hidden test cases are never returned. Get contest ids from repovive_list_contests.

Fetch one contest problem in full: statement, input/output formats, constraints, time and memory limits, tags, sample tests with explanations, and the browser workspace URL. This is the tool to call before solving or submitting.

Build the repovive.com URL where a problem can be read and solved in the browser. Pass contest_id for a contest problem, or problem_set (classics|faang|quant|math) for a curated-set problem. Useful when a capability is website-only.

List in-app notifications for the authenticated account with their ids, titles, messages, read state and timestamps, plus the unread count. Pass the ids to repovive_mark_notifications_read to clear them.

Return how many in-app notifications are unread for the authenticated account — a cheap check before fetching the full list.

Mark the given in-app notifications as read. Take the ids from repovive_list_notifications; already-read ids are harmless.

List the authenticated account's direct-message conversations with their ids, participants, last message and unread counts. The conversation id feeds every other DM tool.

Read the messages in one direct-message conversation, newest page first. Use it to review a thread before replying with repovive_send_direct_message.

Send a message into an existing conversation as the authenticated account. This is visible to a real person immediately and cannot be unsent from here — get the user's approval on the wording first.

Open a new direct-message conversation with a user and send the first message. Resolve recipient_id with repovive_search_users. This reaches a real person — confirm before calling.

Mark every message in one conversation as read, clearing its unread badge.

Delete a direct-message conversation and its history for the authenticated account. This cannot be undone — confirm with the user before calling.

Delete a single direct message the authenticated account sent. This cannot be undone — confirm with the user before calling.

Return how many direct messages are unread for the authenticated account — a cheap check before listing conversations.

List the users the authenticated account has blocked from messaging it, with the block ids needed to undo them.

Block a user so they can no longer direct-message the authenticated account, with an optional reason. Reversible with repovive_unblock_user.

Remove a block so the user can message the authenticated account again. Take the block id from repovive_list_blocked_users.

Fetch a contest's standings — rank, participant, country and total score — capped at the number of rows you ask for. Use it after a contest to see final placement.

Fetch the announcements and clarifications posted by the jury for a contest. Check these when a statement is ambiguous or a problem was patched mid-round.

List the submissions made against one contest problem. Defaults to the authenticated account; pass user_id to look at another participant where the contest allows it.

Summarise how the authenticated account did in one contest: every problem with its points, attempt count and best verdict, plus the total solved. Combines the contest's problem list with the account's submissions.

Fetch one submission by id: its verdict, passed/total counts, judging status, language and timing. Use it to poll a submission that repovive_submit_solution left pending.

Submit source code to a contest problem and, by default, poll until the judge returns a final verdict. This records a REAL submission on the authenticated Repovive account and counts against the ~10 submissions/minute limit — verify locally with repovive_judge_solution first. Returns the submission id, verdict and passed/total.

List the authenticated account's submissions, newest first, with verdicts and timestamps. Optionally filter by problem slug or contest id, and page with page/page_size.

List the ways an account can earn Vive points on Repovive (streaks, solves, contest participation, …) together with the reward each one grants.

Start a paid checkout to buy Vive points for the authenticated account and return the payment URL. This begins a real purchase flow — always confirm the amount with the user before calling.