Code intelligence, grounded in your repo

The code graph that lives next to git.

Find callers, trace dependencies, and give your AI agent context from your codebase. Travsr connects the structure of your code to the tools you already use.

npm install -g @travsr.com/travsr

Open source · Apache-2.0 · Runs locally

The code graph that lives next to git.

  • Apache-2.0

    The core is open source under Apache-2.0, which carries an explicit patent grant rather than just a copyright permission. It was relicensed from MIT so contributors and users both get that protection.

    • Covers the graph construction, storage and retrieval code
    • Relicensed from MIT in pull request #379
    • Daemon, CLI, MCP server and parsers are all in the same tree
    Read the docs on Apache-2.0
  • Runs locally

    Your graph is built and stored on your own machine, next to the checkout it describes. No account is needed and nothing is uploaded to use it.

    • The index lives beside your repository, not in a service
    • No telemetry on your queries, symbols or source
    • A cloud tier exists, and is strictly opt-in
  • npm install

    One global install puts the travsr binary on your PATH. The heavy language tooling is fetched only when a repository actually needs it.

    • npm install -g @travsr.com/travsr
    • Prebuilt binaries for macOS and Linux, x64 and arm64
    • Releases are signed with cosign
    Read the docs on npm install
  • MCP server

    MCP is the only external interface Travsr exposes. There is no REST API and no GraphQL, so anything that speaks MCP can use the graph without a bespoke integration.

    • stdio for a local daemon talking to your editor or agent
    • SSE when you self-host for remote clients
    • Every response is sanitised before it reaches a model
    Read the docs on MCP server

Local. 26 tools. 14 language groups. Apache-2.0.

  • 26 MCP tools

    Twenty-six tools in single-repo mode, covering query, source extraction, repository registry and diagnostics. Most answer straight from the graph with no model involved.

    • Traversal: callers, dependencies, blast radius, execution path
    • Source: snippets, patterns, references, repo map
    • Two hidden diagnostic tools for tracing retrieval
    Read the docs on 26 MCP tools
  • 14 language groups

    Fourteen packaged language groups, parsed structurally by tree-sitter with no compilation step. Deeper semantic analysis is available for a subset on top of that.

    • Phase A parsing needs no build and no toolchain
    • Phase B adds call graphs where a language server exists
    • travsr lang list shows what is available here
    Read the docs on 14 language groups

Migratory birds cross 10,000 kilometers without a wrong turn.

  • Follow a route

    A migrating bird is not searching for its destination. It is following a route it already holds, and that is the difference between traversal and guessing.

    • The structure is recorded once, then walked many times
    • Same question, same answer, every time
    • No ranking model decides what connects to what
  • Not resemblance

    Text search matches spelling, which is why it returns things that merely look right. A local helper called charge() is not the charge() you meant.

    • Name collisions across packages are the common failure
    • Comments and strings match as readily as code
    • Renaming a symbol silently breaks a text-based answer
  • Recorded edges

    Calls, imports and references come from analysis of the source, never from a model guessing what is probably related. An edge exists because the parser found it.

    • Tree-sitter gives the structural edges with no build step
    • LSIF and SCIP add resolved call and reference edges
    • A model can rank these edges but can never create one
  • Scoped identity

    A symbol's identity includes its repository, path, language and signature, so two functions with the same name stay distinct.

    • Kythe VNames give one stable id across repositories
    • The same name in two packages is two nodes
    • Identity survives a file moving, because the id is not the path

Install. Index. Ask.

  • travsr init

    Run it inside a repository and it builds that repository’s graph. It detects installed coding tools and writes project MCP settings where it can.

    • Phase A structural parse runs first and finishes fast
    • Phase B semantic analysis continues in the background
    • travsr status shows how far it has got
    Read the docs on travsr init
  • Detects your tools

    Init looks for coding assistants already installed on the machine and configures what it can reach, then prints whatever is left for you to do.

    • Writes project-level MCP settings, not global ones
    • Anything it cannot configure is reported, not skipped silently
    • Nothing is written outside the repository without asking
  • Project MCP settings

    The configuration is written into the repository, so everyone who checks it out picks up the same server without repeating the setup.

    • Committed with the project, like any other tooling config
    • One server entry, no per-developer paths
    • Works for any client that reads project MCP settings
    Read the docs on Project MCP settings
  • travsr connect --rules

    Agent guidance files are off by default, because writing instructions into someone’s repository uninvited is not a sensible default. Opt in and Travsr will add them.

    • Off unless you pass --rules
    • Writes guidance the agent reads before using the tools
    • Removable without touching the index
    Read the docs on travsr connect --rules
  • Quickstart

    Install, index and ask, in about five minutes on a repository you already have. It assumes nothing beyond Node and a Git checkout.

    • One install, one init, one query
    • No database, container or account to set up
    • Works the same on macOS and Linux
    Read the docs on Quickstart

Understand the change before you make it.

  • get_callers

    Every incoming edge for a symbol, each with a path and a line. This is the question text search answers worst and a graph answers exactly.

    • Returns call sites, not name matches
    • Each result carries path and line
    • Cross-file and cross-language where Phase B is available
    Read the docs on get_callers
  • get_dependencies

    What a file imports, transitively if you ask for it. Depth is bounded so a request cannot pull in the whole repository by accident.

    • Breadth-first over import and depends edges
    • Optional transitive mode with a depth limit
    • Same answer from the CLI with travsr graph --direction deps
    Read the docs on get_dependencies
  • get_blast_radius

    The transitive set a change to this file would reach. It is the question worth asking before an edit, not after one.

    • Walks incoming edges outward until the set closes
    • Tree-sitter or semantic analysis, your choice
    • Ordered so the closest impact is first
    Read the docs on get_blast_radius
  • get_execution_path

    The lowest-cost path between two symbols, plus a corridor of the context around it. Dijkstra with a lambda corridor, not the PCST the tool description still claims.

    • Shortest path first, then the context beside it
    • The MCP description string is stale, see issue #527
    • Returns the route, not a summary of it
    Read the docs on get_execution_path
  • get_context

    Seed, rank, then select source to fit a token budget. Seeds come from the lexical index, ranking is personalised PageRank, and the final cut is a knapsack solve.

    • BM25 and FTS5 trigram for seeds, fused with RRF
    • PPR and k-core to recover the buried middle
    • 0-1 knapsack to fill the budget without overflowing it
    Read the docs on get_context
  • get_snippets

    The actual source for a symbol, extracted from the AST rather than sliced by line count. You get the whole function or a skeleton, not a truncated fragment.

    • Full body or skeleton, whichever fits the budget
    • Boundaries come from the parse, so nothing is cut mid-expression
    • Feed it the names the traversal tools returned
    Read the docs on get_snippets

A map becomes useful when every point connects.

  • Bird form

    A silhouette. The points are placed so a person reads a bird, which means the meaning lives in the arrangement and none of it lives in the points.

    • Move one point and the meaning degrades, because position is all there is
    • Nothing here answers a question: there is no "what connects to this"
    • Every picture of a codebase works this way, which is why they go stale
  • Graph form

    The same points with recorded edges between them. The meaning moves out of the arrangement and into the structure, so it survives being laid out any other way.

    • Callers, blast radius and execution paths are all walks over these edges
    • Re-lay it out however you like and the answers do not change
    • This is the thing an agent traverses instead of guessing from text

In your editor. Alongside your agent.

  • Context explorer

    Browse exactly what the graph would hand an agent for a query, before you hand it over. It shows the selected symbols, their scores and what the budget spent.

    • See the selection, not just the answer
    • Adjust the query and watch the set change
    • Copy the whole context into a chat in one action
    Read the docs on Context explorer
  • Dependencies panel

    What the open file depends on, live, updating as you move between files. No command to run and no output to read.

    • Follows the active editor
    • Direct and transitive, with a depth control
    • Click through to the defining file and line
    Read the docs on Dependencies panel
  • Execution path

    Trace a route between two symbols without leaving the editor. Pick a source and a sink and the path is drawn over the files it passes through.

    • Dijkstra over the recorded call edges
    • The corridor of nearby context comes with it
    • Useful for understanding a failure you can only see at the ends
    Read the docs on Execution path
  • CodeLens

    Caller counts sitting above your symbols as you work, so the cost of changing something is visible before you change it.

    • Counts come from the graph, not from a text scan
    • Click the count to list the call sites
    • Updates as the daemon reconciles your saves
    Read the docs on CodeLens
  • Hover cards

    Graph facts about a symbol without leaving the line you are on: what calls it, what it depends on, where it is defined.

    • No jump to definition needed to see the shape
    • Shows identity, so name collisions are obvious
    • Falls back cleanly when a language has no Phase B
    Read the docs on Hover cards
  • Graph stats

    Node and edge counts, schema version and the last indexed commit. The fastest way to tell whether what you are querying is current.

    • Staleness is a bug, so the last commit is shown plainly
    • Counts by node kind and edge kind
    • Matches travsr status on the command line
    Read the docs on Graph stats
  • Languages panel

    Which languages have semantic analysis available in this repository, and which are structural only. It tells you what a given answer can and cannot know.

    • Phase A is always there once the repo is parsed
    • Phase B depends on the language tool being installed
    • Matches travsr lang list
    Read the docs on Languages panel
  • Repos panel

    Every repository registered with the daemon, in one list. In global mode a single MCP server answers across all of them.

    • Register many repositories, query through one server
    • Remove or prune entries that no longer exist
    • Identity stays scoped, so names do not collide across repos
    Read the docs on Repos panel
  • Synonyms panel

    Teach retrieval that two terms mean the same thing in your codebase. It is deterministic configuration, not a model guessing at your vocabulary.

    • Applied at query expansion, before any ranking
    • Stored with the repository, so the team shares them
    • Reset to the defaults at any point
    Read the docs on Synonyms panel
  • Repo files

    The indexed file tree as the graph actually sees it, which is not always the same as what is on disk.

    • Shows what was parsed, not what was globbed
    • Ignored and unparsed files are visible as such
    • A quick way to spot a language package you are missing
    Read the docs on Repo files

Structure first. Deeper analysis when you need it.

  • In-process Phase B

    Semantic analysis runs inside the daemon with no external binary to install, resolving calls and references across files.

    • TypeScript and JavaScript, Rust, Python
    • Nothing to install beyond travsr itself
    • Resolved call and reference edges, not only structure
    Read the docs on In-process Phase B
  • Dart, via SCIP

    Dart resolves through a first-party SCIP emitter - an external Dart binary rather than the in-process path - and lands the same kind of edges.

    • travsr-lang-dart, shipped by this project
    • An AOT binary, so it is installed separately
    • Produces the same resolved edges a different way
  • Structural, plus a sidecar

    Parsed by tree-sitter with no build step. Deeper analysis arrives once that language's analyzer is installed, and it runs sandboxed.

    • Go, Java, Kotlin, Scala, C#, C / C++, Ruby, PHP, Swift, Objective-C
    • travsr lang install <lang> adds the analyzer
    • The sidecar runs behind a per-corpus trust grant
    Read the docs on Structural, plus a sidecar

Start with a symbol. Or start with a question.

  • search_symbol

    Find symbol definitions by name, with deterministic normalisation. No embedding is involved, so the same query returns the same definitions every time.

    • Exact, prefix and normalised name matching
    • Results are definition sites with path and line
    • Scoped by repository, so collisions stay separate
    Read the docs on search_symbol
  • find_references

    Every use site of a symbol across every indexed language: inline expressions, assignments and type references, not just calls.

    • Wider than get_callers, which is call edges only
    • One line per occurrence, with a path
    • travsr references does the same from the shell
    Read the docs on find_references
  • find_pattern

    Structural regex search bounded to the graph’s own file set, so it never wanders into build output or vendored code.

    • POSIX extended regex, or a fixed string
    • Scope it to a path prefix or to files importing a symbol
    • Deterministic: no model, no API key
    Read the docs on find_pattern
  • travsr embed init

    Optional local embeddings for broader natural-language discovery. They widen what is found and never decide which relationships exist.

    • Off by default, and fail-open when absent
    • Runs locally; nothing is sent anywhere
    • Only ever affects seed selection, never edges
    Read the docs on travsr embed init
  • Local rerank

    A cross-encoder scores candidates and can decline weak matches. It reorders what traversal already found and cannot invent a new result.

    • ONNX model run locally through tract
    • Reranks candidates only, never determines edges
    • Optional, and the pipeline works without it
    Read the docs on Local rerank
  • Token budget

    Selection is a 0-1 knapsack over ranked candidates, so the context fits the budget you asked for instead of being truncated at the end.

    • You set the budget; the solver respects it
    • Whole symbols in or out, never half a function
    • What was dropped is reported, not hidden
    Read the docs on Token budget

Your next answer starts with your repo.

  • GitHub

    Source, issues and releases. The architecture decisions are recorded in the repository as ADRs, so the reasoning is readable too.

    • Apache-2.0, developed in the open
    • RFCs and ADRs live beside the code
    • Signed releases for macOS and Linux
    Read the docs on GitHub
  • VS Code extension

    Every editor surface in one install: context explorer, dependencies, execution path, CodeLens, hover cards and the panels.

    • Talks to the same local daemon as your agent
    • No separate index and no second configuration
    • Works alongside whatever assistant you already use
    Read the docs on VS Code extension
  • Docs

    CLI reference, every MCP tool, recipes and the architecture. Written for someone deciding whether the model fits their codebase.

    • One page per MCP tool with real arguments
    • CLI reference for every command and flag
    • Architecture notes, including what was tried and dropped
    Read the docs on Docs