Get Kin running in a few minutes.

Please set up Kin for this project. Kin is the system of record for AI-written software.
It lets you ask the graph where code lives instead of searching files for it.

Work from the root of the repository we are setting up.

First install the CLI.

  curl -fsSL https://get.kinlab.dev/install | KIN_NO_SETUP=1 sh
  exec "$SHELL" -l

Then admit this repository into the graph. Kin reads the whole reachable Git history, so a
large repository can take a while. This cost is paid once.

  kin init

After init the daemon keeps preparing in the background, so the first agent calls on a large
repository can take noticeably longer to answer.

Now wire the agents. This detects the AI clients Kin supports and registers its MCP
server with each one it finds.

  kin setup --intent agent

Confirm it worked before going further.

  kin setup doctor

Check that the MCP clients line reports ok.

Now install the language servers. Kin resolves references across files through a language
server for each language in the repository, and a fresh host usually has none, so do this
before you rely on find_references.

  kin doctor --fix --install-language-servers

Kin uses a toolchain you already have when there is one, and otherwise downloads a release
binary it checks against a digest it ships with. It prints what it installed and where it came
from, and it tells you when the server it installed still needs something Kin will not install
for you. Rust is the case worth knowing: rust-analyzer reads a project by running cargo, so on
a machine with no Rust toolchain it starts and resolves nothing, and Kin says so. If it reports
that it could not finish, keep going. Everything else works, and Kin reports reference edges as
pending for that language rather than telling you a symbol has no callers.

Then restart your AI client completely, because clients read their MCP configuration at
startup and will not see Kin until they do.

After the restart you should see Kin tools available, including semantic_locate,
get_context_pack, and find_references. find_references answers for a language only once its
language server is installed, which is what the step above is for. A good first request looks
like this.

  Use Kin to explore this codebase. Run semantic_locate to find the main entry point, then
  get_context_pack on that file.

From here, prefer Kin's semantic tools over grep and raw file reads when you are exploring
this repository. Use semantic_locate to find symbols by meaning, get_context_pack to pull a
structured bundle around a file or symbol, and find_references to see what depends on an
entity. These read the graph directly and return what the repository actually recorded rather
than what a text match happened to hit.

One note on platforms. This works on macOS, on Linux, and on Windows. Native Windows
support is early and x64 only; use WSL2 on Arm.