Try Kin on your computer.

Please set up Kin for this project. Kin records named code, resolved relationships and changes as repository data, with familiar files available to supported tools.
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 Kin and connect the AI clients on this machine. One command does both, and it
is the same on macOS, Linux, Windows and WSL. It needs Node 20 or newer.

  npx -y @kinlab/kin setup --intent agent --no-interactive

If this machine has no Node, use the installer instead. It puts the same binaries in the same
place.

  curl -fsSL https://get.kinlab.dev/install | KIN_NO_SETUP=1 sh

Either way Kin lands in ~/.kin/bin and adds that directory to your shell profile, so start a
new login shell before you use the bare name.

  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.

Some clients record the repository they answer for, so run setup once more from inside the
initialized repository to pick those up.

  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.