Repo-first public beta

Submit your repo. Find the right files before the work begins.

Repokit helps developers and AI agents locate the most relevant files for a coding task inside one repository. Connect GitHub, activate a supported repo, then verify the results on your own code through API or MCP.

Submit your repo View live demo Read docs

GitHub-first onboarding

API + MCP access

Verify on your own code

Product mockup

find_relevant_files

Repository ready

Task

Fix request validation error in routing after auth middleware refactor

Ranked filestop_k = 3

#1 app/routing.py

Routes and request validation flow

96% relevance

#2 middleware/auth.py

Middleware refactor likely affects request path

89% relevance

#3 tests/test_routing.py

Failing coverage around validation logic

83% relevance

GitHub-first
Python / JavaScript / TypeScript
API + MCP
Public beta
Repo-specific verification

Built for real repository workflows, not generic code search.

Problem / solution

Stop searching the repo. Start with the files that matter.

Repokit does not try to replace your editor. It helps you start from the right files first.

Where time gets lost

Large repos are hard to navigate when a task lands cold.
Developers lose time rediscovering code structure before real work starts.
AI agents consume irrelevant context and reason from the wrong files.
New contributors struggle to find the implementation surface quickly.

What changes with repo-aware retrieval

Task-aware repository file ranking inside one repo.
Faster setup for debugging, feature work, and evaluation.
Better repo context for agents before planning or editing.
Less wasted attention and token usage on low-signal files.

How it works

From repo submission to proof on your own code

Step 01

Connect GitHub

Connect the GitHub installation that owns your repository.

Step 02

Activate your repo

Choose a supported Python, JavaScript, or TypeScript repository.

Step 03

Track readiness

Watch the stage bar move through onboarding, training, evaluating, and ready.

Step 04

Verify the claim

Issue a verification token and query the repo through API or MCP once it is ready.

Stage bar

submitted → onboarding → training → evaluating → ready

Ready means the repo is being served. Submission alone does not mean it is live yet.

01
submitted
02
onboarding
03
training
04
evaluating
05
ready

Interactive demo

See how a task becomes a ranked file shortlist

Switch between realistic task examples and inspect how repository-aware file ranking changes the shortlist.

Task

Fix request validation error in routing after auth middleware refactor

Repository context

Repository readyrecent files: middleware/auth.pyfailing tests: tests/test_routing.py

Ranked results

Guidance, not an edit plan

#1 app/routing.py

Routes and request validation flow

Touches validation flow

#2 middleware/auth.py

Middleware refactor likely affects request path

Recently involved in auth path changes

#3 tests/test_routing.py

Failing coverage around validation logic

Likely connected via failing tests

Treat the output as ranked guidance, not an automatic edit plan.

Use cases

Useful the moment you need repository context

The product stays narrow, but the retrieval layer becomes useful across common repository workflows.

Bug fixing

Jump directly to the files most likely tied to a regression.

Feature work

Find the implementation surfaces a change is most likely to touch.

New repo onboarding

Help new engineers understand where to begin.

AI-agent retrieval

Give agents better context before they plan, answer, or edit.

Test failure triage

Use failing tests as signals to rank likely source files.

Large codebase navigation

Reduce blind searching across unfamiliar repositories.

For developers / For AI agents

Built for developers and AI agents

For developers

Use the API when you want direct control.

Integrate file ranking into internal tools.
Improve editor and debugging workflows.
Send task context through HTTP + JSON.
Use response metadata for evaluation and feedback.

Explore the API

For AI agents

Use MCP when your client already speaks tools.

Connect an MCP-capable client to the hosted endpoint.
Avoid building your own wrapper.
Retrieve better repository context before reasoning.
Reduce hallucinations from irrelevant files.

Explore MCP

API vs MCP

Two access paths. One retrieval layer.

API and MCP expose the same repository-aware retrieval layer. Choose the interface that matches your workflow.

API

Use direct HTTP requests when you are building your own workflow.

You want direct HTTP requests.
You are building your own workflow.
You want structured backend integration.

API examplebash

curl -sS \
  -H "Authorization: Bearer <your_token>" \
  -H "Content-Type: application/json" \
  https://api.repokit.live/find_relevant_files \
  -d '{
    "repository_id": "<repository_id>",
    "query": "fix request validation error in routing",
    "top_k": 5
  }'

Open API page Check API health

MCP

Use tool-style access when your client already supports MCP.

Your tool already supports MCP.
You want tool-style access.
You want a simpler agent integration path.

MCP examplebash

curl -sS -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <your_token>" \
  https://mcp.repokit.live/mcp \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "find_relevant_files",
      "arguments": {
        "repository_id": "<repository_id>",
        "query": "fix request validation error in routing",
        "top_k": 3
      }
    }
  }'

Open MCP page Check MCP health

Submission / readiness

What happens after you submit a repository

The beta is operationally concrete. Supported repositories still need time before they are ready to serve.

01
submitted
Accepted into intake.
02
onboarding
Repository artifacts are being prepared.
03
training
Ranking inputs are being prepared.
04
evaluating
Runtime is being checked before serving.
05
ready
Runtime active and ready for verification.

Supported today

PythonJavaScriptTypeScript

Public beta behavior

Supported repos auto-start the happy path while intake is active.
The repo still needs processing time before it becomes ready.
Sparse or unusual repositories may stop early and require operator inspection.

What ready means

A runtime is active and the repository is being served.

Verification token

When your repository reaches ready, the submission detail gives you a verification token and repo-specific next steps for API or MCP.

FAQ preview

Clear answers before you submit

The public beta is intentionally narrow. The FAQ keeps the expectations concrete.

Read full FAQ

Repokit is a repository-aware retrieval product for developers and AI agents. It ranks the files most worth inspecting for a coding task inside one repository.

Final CTA

Bring your repo in. Verify the claim yourself.

Connect GitHub, activate a supported repository, and test repository-aware retrieval on your own code through API or MCP.

Submit your repo Read docs Explore API + MCP