searchcode enterprise — what it does

Code search and code intelligence for your whole estate, self-hosted, with a first-class interface for AI agents. One binary, one config file, your hardware.

The short version

• Search every repository you own, from a browser or from an agent, with the same authorisation decision behind both.
• Runs entirely on your infrastructure. No outbound connection unless you configure one, and never to us, on any tier.
• Built for agents as a first-class surface, not as a bolt-on: 27 MCP tools over the same API the web interface uses.
• One binary. No database server, no message queue, no search cluster, no sidecar.
• Every feature on every tier. Nothing is licence-gated. Tiers differ in repository count and user count, and in nothing else.

Search

• Full-text code search across the estate or one repository, with a query language people already know: phrases, boolean operators, regular expressions and fuzzy matching.
• Filters that match how developers think: by language, by repository, by path, by file extension.
• Faceted results. Language, repository and technology counts alongside the hits, so a broad query narrows in one click.
• Ranked, not just matched. Results are scored and tuned server-side, with the knobs in the operator's config rather than in every caller's query.
• Two search engines, chosen per repository automatically. A signature index for repositories large enough to benefit, brute force for the rest. Every candidate is verified before it is returned, so the index makes queries faster and never changes the answer.

Reading code

• File view with syntax highlighting and per-file findings.
• Symbol outline for every file, extracted with real language grammars rather than guessed with regular expressions.
• Code navigation: jump to a definition, list references, in one repository or across the whole estate.
• Confidence is labelled, always. A declaration read by a grammar is marked exact; a heuristic match is marked probable. The product never presents a guess as a fact.
• History, blame and a file tree, with permalinks that pin a commit rather than a branch.

Code intelligence

• Language and technology detection across the estate: what is written in what, and which frameworks and libraries are actually in use.
• Dependency inventory from 19 manifest and lockfile parsers across six ecosystems, with version resolution and direct-versus-transitive distinction.
• Vulnerability findings joined from an offline advisory database, with four comparison semantics because a generic version comparator is wrong in the direction of false negatives.
• Licence audit reporting only what a manifest actually states. Anything else is reported as unknown, never as unlicensed.
• Quality and security findings per file, with counts rolled up per repository.
• Complexity hotspots and change coupling, computed from the commit history: which files are both complex and frequently changed, and which files keep changing together.

For agents

• MCP over streamable HTTP, with an OAuth 2.1 authorization server built in, so an agent gets a credential through the same sign-in your people already use.
• 24 tools, and every one of them is a real API call. The tool surface is generated from the API definitions, so a tool cannot exist without an endpoint behind it and the two cannot drift.
• Every tool on every tier. A tool an agent can see and cannot call is worse than useless: it burns a call and teaches the agent to route around the product.
• Per-agent credentials, not a deployment key. Credentials are per user and per client, named at creation, individually revocable, with last-used tracking. Every call resolves to a real person and is authorised as that person.
• Answers written for a model to read. Truncation and coverage gaps are stated in the text, not only in a structured field a client might drop.
• A plain REST API too, with a generated OpenAPI document and a rendered reference that needs no internet to read.

Getting your code in

• Clone from any git host over HTTPS or SSH, listed one at a time or by whole organisation.
• Code-host connections for GitHub and GitLab, cloud or self-managed, including GitHub Enterprise Server and self-hosted GitLab. Point it at an organisation or a group and it keeps the list current.
• Directory sources for estates that do not live in git: a mount, an export, a Perforce or mainframe drop. A directory of 2,000 projects becomes 2,000 repositories.
• A CLI that enumerates a code host into a config fragment you review and commit, so the repository list stays something a human approved.
• Incremental refresh. Repositories are re-fetched on a schedule, and only what changed is re-analysed.
• Partial answers are reported as partial. A rate limit, an unreachable target or a missing credential produces a named gap saying what is missing and why, never a silently short list.

Access control

• One authorisation decision, one place. Search, file view, blame, history, the API, MCP and every aggregate derive from the same function. There is no second path to drift.
• Filtered at query time, never after. A repository you cannot see is never read, so result counts and response times leak nothing about it.
• Repositories you cannot see return "not found", not "forbidden", because a forbidden response confirms a repository exists.
• Group-based grants, declared in config, evaluated as a union so no rule ordering can change who sees what.
• Explain access: ask why a given person can or cannot see a given repository and get the answer with the reasoning, not a yes or no.
• Three sign-in modes: your existing SSO through an authenticating proxy, built-in local accounts, or open for an evaluation. Exactly one is active.

Operations

• One binary and one YAML file. Unknown keys are a startup error naming the key and the line, not a silently ignored block.
• Hot reload for most settings; the rest are named as restart-only and a reload carrying one is refused by name rather than half-applied.
• Prometheus metrics on their own port, so a network policy can scope who scrapes them.
• Health and readiness endpoints that behave properly under Kubernetes: readiness never waits for repositories to finish cloning.
• A shipped Grafana dashboard and alert rules, kept in step with the metrics the product actually exports.
• searchcode doctor, which diagnoses the failures that are otherwise invisible from outside a container, and produces a support bundle that is safe to send: an allowlist of fields, with secrets scrubbed by where they came from rather than by what they look like.
• Deploy how you like: Docker, Helm, systemd, or a self-contained tarball that installs into one directory and uninstalls with rm -rf.

Audit

• Every access decision recorded, on every tier, with no switch to turn it off.
• A stable, versioned record written for your SIEM: additive changes only.
• Four destinations: file, stdout, stderr or syslog, with a retention window you choose.
• Joinable to the application log by a request identifier, so a refusal can be traced from the compliance record to the line of code that made it.

Security posture

• No outbound connection unless you configure one. Exactly three things can: a code-host connection, OTLP tracing and a remote syslog sink. The last two are off by default and the first is absent by default.
• Never to the vendor. No telemetry, no phone-home, no licence check over the network, on any tier.
• The advisory database ships with the product and is never fetched at runtime, which is what makes air-gapped installation work rather than merely tolerated.
• internal-only egress mode refuses a public code host at config load, so "we do not talk to the internet" is enforced rather than promised.
• Offline licence verification. An absent, expired or invalid licence degrades to community mode and never stops the process.
• Untrusted-by-default content handling. Every repository in the estate is untrusted input, so raw file content is served with the headers that stop it executing as a page.
• Runs unprivileged on a read-only root filesystem, as a non-root user, with a generated network policy in the Helm chart.

Air-gapped

Everything above works with no internet access at all: the advisory database is compiled in, the licence verifies offline, the API reference is server-rendered with no external assets, and the product never contacts an identity provider in any mode.

Also available: the hosted service

api.searchcode.com offers the same code intelligence for public repositories, on demand, with no installation: point it at a public repository URL and it clones, analyses and answers, over MCP or plain REST. It is the fastest way to try the tools before deciding to host them.

What it deliberately does not do

Stated because these are decisions, not gaps.

• No agent inside the product. It is a tool server; the agent lives in your client, where the context is.
• No secret validation. The product never uses a credential it finds to test whether it is live.
• No searchable index of secrets. Findings are counts and locations.
• No deployment-wide agent key. Every agent call resolves to a person.
• No feature gates. Tiers are repository count and user count. That is the whole list.