Project-Lens
Provides Git-aware project discovery and metadata: detects Git repositories, reports each project's remote, current branch, and clean/dirty status live, respects .gitignore in file listings, and can initialize a Git repository when scaffolding a project if writes are enabled.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
Project-Lens
A Model Context Protocol server that gives your AI coding agent a map of every project on your machine.
Coding agents are good at working inside one repository and blind outside of it. Ask one about a project in a sibling
directory and it starts guessing paths, shelling out to find, and burning context on directory listings that mostly do
not matter.
Project-Lens fixes that. It scans the workspace roots you configure, builds a registry of every version-controlled
project it finds, and exposes eleven tools that let an agent answer questions like "where is the payments service?",
"which of my repos are on a dirty branch?" or "which project defines TransactionManager?". Each in a single call,
with responses shaped to be cheap in tokens rather than pretty to a human.
Design points worth knowing up front:
Stateless. Built on the MCP revision with the current
@modelcontextprotocol/serverv2 SDK, following its recommended server factory pattern. No session state is held between requests, so instances are interchangeable (scale them vertically or horizontally, restart them freely, run several side by side against different roots). Older 2025-era clients are still served through SDK version negotiation.Sandboxed by construction. Every path an agent supplies is resolved against a known project root;
../, absolute paths and symlinks that escape are rejected. Files matching secret patterns are invisible to every tool.Read-only by default. The two tools that mutate anything are not even registered unless you explicitly enable writes, so a confused or prompt-injected client cannot call what does not exist.
Token-frugal. Compact JSON, explicit truncation flags, and a positional
{fields, rows}matrix for bulk listings, one call to sweep a whole workspace instead of one call per project. Measured at 11.3× cheaper than the equivalent per-project calls.
Why it exists
The project started from a recurring annoyance: an agent that already had a perfectly good picture of the repository it
was in had no idea that a dozen related repositories sat next to it. Every cross-project question turned into the same
ritual (ls a few directories, guess at a name, find for a file, read a package.json to work out what the thing
even is). Each step cost tokens, several steps returned nothing useful, and the agent still ended up asking which folder
to look in.
The underlying problem is that a workspace has structure the filesystem does not express. You know that
Work/Payments/Gateway is a service, that Work/Payments groups related services, and that the archived folder next to
them is dead weight. An agent shelling out to find knows none of that and cannot learn it without paying for a
directory walk every single time.
Project-Lens turns that structure into a queryable registry built once at startup, and puts a small, deliberately shaped tool surface in front of it:
One call per question. A whole-workspace metadata sweep is one
list_projectscall with a projection, not Nproject_infocalls.Responses sized for a context window. Positional rows instead of repeated keys, capped lists with an explicit
truncatedflag, per-line excerpt caps on search hits.A boundary the agent cannot cross. Reads and writes are scoped to a resolved project root, secrets are filtered out before anything is returned, and mutation is off unless you switch it on.
Related MCP server: agenticscope
How it works
A directory containing .git or .svn is a project. The folders between a configured root and that project become its
group path, at arbitrary depth (Work/Payments/Gateway is a project named Gateway in group Work/Payments).
Groups are whatever your directory layout already says they are; there is nothing to declare.
SVN working copies are indexed and visible, but the svn binary is never invoked, so their remote, branch and clean
state stay null. Git projects get all three, queried live on the calls that report them.
Projects are addressed by a bare name (Gateway) when it is unique, or by the group-qualified path
(Work/Payments/Gateway) when it is not. When two roots hold the same group-qualified path, both copies stay indexed
and each is addressed by its absolute path. Matching is case-insensitive; an ambiguous name returns the qualified keys
(or the absolute paths, for such twins), a miss returns the closest matches.
Freshness: full scan at startup, an explicit refresh_registry tool, plus mtime revalidation of root and group
directories piggybacked onto registry calls. No filesystem watcher, no disk cache, nothing to invalidate by hand.
Tool | Purpose |
| Tree overview: 1 = groups, 2 = groups → projects (default), 3 = + each project's top-level folders |
| Flat list of group paths |
| Projects as |
| Name match (case-insensitive; also ignoring spaces, |
| Path, VCS remote/branch/clean state, detected stack, key manifests, README snippet |
| ripgrep content search over one project, one group, or every registered project; results grouped one entry per file |
| Paths relative to the project root; respects |
| Scoped read; a line slice is streamed and ends with |
| Off by default. Scoped write; creates parent dirs inside the root |
| Off by default. Asks the user to confirm. Create |
| Force a full re-scan, returns scan stats |
Narrowing a search. search only scans the directories of the projects in scope, never the whole root, and takes
four parameters that narrow it further: path_prefix (a subdirectory of each project), glob (passed to rg -g),
exclude (per-call pruning), and context_lines (0–3, default 0). The tool description steers the model toward
these before widening to scope: "all".
Results come back grouped one entry per file, with hits as positional [line, excerpt] pairs:
{
"query": "TransactionManager",
"scope": { "scope": "all" },
"files_matched": 12,
"hits_returned": 34,
"truncated": false,
"results": [
{
"project": "Gateway",
"file": "src/tx/Manager.java",
"lines": [[14, "public class TransactionManager ..."], [88, " return new TransactionManager("]]
}
]
}Ripgrep output is read as a stream and stopped as soon as limit is reached, so a query matching a hundred thousand
lines costs the same as one matching fifty.
Path traversal is rejected on every tool that takes a relative path
../, absolute paths and symlinks pointing outside the resolved project root.Secret-pattern files and
.gitare invisible..env*,*credentials*,.npmrc,.netrc,.pgpass,.htpasswd, SSH keys (id_rsa*,id_ed25519*,id_ecdsa*,id_dsa*), and key or certificate stores (*.pem,*.key,*.p12,*.pfx,*.jks,*.keystore,*.kdbx) never appear in key files, listings, search results orread_fileoutput, andwrite_filerefuses them. No path with a.gitsegment can be read, searched or written.Remote URLs are sanitised.
project_infostrips userinfo (user:token@) from git remotes before returning them.Writes are unregistered, not merely refused, unless explicitly enabled a client that connects without them cannot call them at all.
Untrusted config cannot widen scope. A per-root
.project-lens.jsonmay only setexclude; a cloned repository cannot switch writes on or add roots.Failures are loud. Malformed configuration aborts startup rather than running with a silently changed scope.
Writes never go through a symbolic link in the last path component, wherever it points:
write_filerefuses it, and opens the file withO_NOFOLLOWso none can be swapped in afterwards. A platform withoutO_NOFOLLOW(Windows) refuses every write rather than lose that protection.A repository's own configuration runs nothing. The git commands behind
project_infoandlist_projectsrun withcore.fsmonitoroff, every clean, smudge and process filter the repository's own config defines blanked, and submodules ignored; ripgrep starts with--no-config. Filters from your global or system config, such as git-lfs, keep working.is_cleanreports the repository's own files, not changes inside its submodules.
What the server does not protect against. Project-Lens bounds where an agent can read and write. It does not judge what it reads, and it runs with your user's permissions.
Prompt injection. Everything a tool returns — the README lines in
project_info'sreadme_snippet, file contents, search excerpts — is text from the workspace, which may come from a repository someone else wrote. An agent can read instructions planted there and follow them.Enabling writes widens what injected text can do. With
allow_writeson, an agent can write any non-secret file outside.git: source code, build scripts, CI files. Those run later, through your own tools, outside this server's control. Turn writes on only for workspaces whose contents you trust, and review what the agent writes.The scaffold confirmation trusts the client. The question reaches you through the MCP client, which also sends your answer back. A client that answers by itself, without showing the form, gets the project created. The confirmation guards against the agent acting alone, not against a dishonest client.
It is not a sandbox. The server does not isolate the agent from the rest of your machine; it only refuses paths outside the projects it registered. Other tools the agent has are not affected.
A workspace another OS user can write to is out of scope. Between checking a path and opening it, a folder in the middle of the path could be swapped for a symbolic link. Only a process writing in the workspace at that moment can do it, and one running as your own user already has your permissions, so this matters only when another OS user can write to a root. Keep your roots writable by you alone.
Benchmarks
All figures come from one machine, one session, against a workspace of 42 projects across 16 groups with no
exclusions configured and a pinned sample project. Your numbers will differ; reproduce them with npm run bench,
npm run bench:store and npm run bench:tokens.
Read the two halves differently. Token counts are deterministic, the same workspace and sample give the same
integers every run, so any movement is a real change. Latency is deterministic nowhere: project_info alone spans
12% across consecutive runs of identical code. Treat latency as a tripwire against the SLA column, not as evidence that
one revision beat another.
npm run bench, 100 iterations per tool:
Tool | mean | p95 | SLA |
| 0.56 ms | 0.77 ms | < 15 ms |
| 0.47 ms | 0.51 ms | < 15 ms |
| 0.53 ms | 0.61 ms | < 20 ms |
| 0.51 ms | 0.58 ms | < 15 ms |
| 5.53 ms | 6.01 ms | < 100 ms |
| 6.63 ms | 7.21 ms | < 80 ms |
| 9.46 ms | 10.36 ms | < 80 ms |
| 71.64 ms | 79.57 ms | < 500 ms |
p99 is deliberately not reported: at 100 iterations the 99th percentile is the maximum, so printing both would show
one number twice and read as though the second corroborated the first.
Every project-scoped row depends on which project got sampled, and that drift dwarfs the run-to-run noise. Unpinned,
the harness takes whichever project sorts first by group-qualified key, so the sample moves as the workspace does. On
the same machine at the same commit, search (one project) measured 6.63 ms against one sample and 7.54 ms against
another enough to take the cost of widening to scope: "all" from 43% to 23%. Always pin:
LENS_BENCH_PROJECT="<group>/<Project>" npm run benchRegistry internals (npm run bench:store): cold scan ~86 ms, getAll() 0.11 µs, find() 3.6 µs, 10.5 MB heap
used. Three caveats, because each is a different kind of measurement. The cold scan is a single sample that folds in
OS page-cache state and module load, so it moves ±10 ms and is reported rounded. getAll() is timed as one 10
000-iteration batch and its result is consumed (per-iteration timing would have measured performance.now() itself, and
an unconsumed result is free for the JIT to delete). find() is quoted as the median: its mean is 9.2 µs against a
3.6 µs median, because the first call carries JIT warm-up.
npm run bench:tokens, real claude-opus-5 counts. Each row compares one MCP call (request framing plus response)
against the shell command a model would otherwise run for the same information, script text included.
Scenario | mcp | shell | ratio |
| 652 | 1275 | 0.51 |
| 207 | 359 | 0.58 |
| 124 | 210 | 0.59 |
| 3332 | 5221 | 0.64 ± |
| 255 | 375 | 0.68 |
| 989 | 978 | 1.01 |
| 391 | 382 | 1.02 |
| 155 | 109 | 1.42 |
| 1344 | 785 | 1.71 |
| 108 | 62 | 1.74 |
| 2263 | 1275 | 1.77 |
| 97 | 54 | 1.80 ± |
± marks the two rows that do not reproduce: both sides stop at 50 hits and ripgrep's traversal order picks which 50.
Every other row is exact.
The headline number is not in that table. The metric that matters for bulk work is the projection: 1344 tokens for
a 42-project metadata sweep against 15 173 for 42 individual project_info calls 11.3× smaller, past the ≥10× design
target. The {fields, rows} matrix bought most of that; the array-of-objects shape it replaced scored 6.6×.
Rows above 1.0 are honest The list_projects rows stay above parity by design, the shell baselines print strictly
less (find emits only paths; the sweep loop emits only branch plus porcelain status) while list_projects also
carries name and group. The same asymmetry runs the other way in the strongest row: map_workspace is compared against
a find emitting bare paths against a tool returning a tree, so part of its 0.51 is a discount for answering a smaller
question. And the search (project) row found nothing at all (the pinned sample has no TODO) so its 1.80 is a fixed
response envelope weighed against a command that printed nothing. It is published rather than deleted because dropping
it would hide that the pinned sample cannot exercise that path.
Schema cost. All eleven tool schemas cost 2710 tokens, but a default session loads nine (write_file (298) and
scaffold_project (254) are not registered unless writes are enabled) so the real one-time cost is 2158 tokens.
Four map_workspace calls repay it. Repayment is quoted against the best stable scenario: search (scope: "all")
saves far more, around 1900 tokens a call, but a headline built on it would be advertising precisely the unnarrowed call
the tool's own description tells the model to avoid.
search is the most expensive schema at 658 tokens, a third of it the path_prefix, exclude and context_lines
parameters (a one-time cost against a tool whose single unnarrowed call runs into the thousands, so those parameters pay
for themselves the first time the model uses one). Every parameter of every tool carries a description, which is most of
the difference between the nine-tool figure and a bare-schema server. It is worth the tokens: one read_file that
guesses the project key wrong costs a rejected call plus a find_project round trip to recover.
The schema figures predate the tool annotations and the scaffold_project root argument, which together take the
eleven schemas from 8594 to 9613 bytes (counted with the in-memory client); they were not re-measured in tokens.
One asymmetry is not corrected for: MCP is charged for its tool schemas and the shell is not. A model calling out to a shell pays for the Bash tool's schema too, and that cost never appears in the shell column. Every ratio here is therefore slightly pessimistic about MCP: the conservative direction, which is why it is left in.
Both shell baselines pass -M 300 --max-columns-preview, giving them the same per-line cap the tool applies to its
excerpts. Both flags are load-bearing. -M 300 alone does not cap a long line, it drops it:
$ rg -n --no-heading -M 300 TODO vendor/bundle.min.js
2:[Omitted long matching line]That is 26 characters where the tool would have paid 300 (a silent subsidy to the shell on exactly the minified and
vendored files the cap exists to handle). --max-columns-preview turns the omission back into a truncation, which is
what the tool's excerpt cap actually does.
Some cap is non-negotiable: without one, a single minified line blows the comparison up, and the row swung between 1.1
MB and 17.9 MB depending on which lines head -50 happened to catch. Worth knowing as a property of the naive command
(an uncapped rg | head -50 really can put megabytes into a context window).
Without an API token the harness counts UTF-8 bytes and labels itself DEGRADED. That error is a bias, not noise.
Run back to back on the same workspace, bytes scored higher than tokens in all twelve rows, never once lower:
Scenario | tokens | bytes | |
| 1.01 | 1.02 | +1% |
| 1.02 | 1.04 | +2% |
| 0.68 | 0.70 | +3% |
| 1.77 | 1.86 | +5% |
| 0.64 | 0.71 | +11% |
| 1.42 | 1.57 | +11% |
| 1.74 | 2.04 | +17% |
| 0.59 | 0.71 | +20% |
The mechanism is visible in the ordering: the read_file rows are mostly prose and land within 2%, while rows dominated
by paths, keys and JSON punctuation are off by 10–20%, because the tokenizer packs those far better than one byte per
token and they are exactly what the MCP side of a row is made of. Bytes mode always flatters the shell. Good enough to
spot a regression on a large payload, never a source for a published ratio.
Exclusions move every number here. Excluding a tree removes its projects from the registry entirely, which shrinks
the startup scan, the candidate set for every search, and the size of every listing response but also makes those
projects unresolvable by name from every tool, not just from search. On the benchmarked workspace, excluding one
archive directory took list_projects from 42 rows to 14, the startup scan from 70 ms to 17 ms, and the candidate set
for a TODO search from 465 files to 25. The configuration is part of the measurement, not context for it.
For users
Requirements
On the machine that runs the server:
Node.js ≥ 22
gitonPATHripgrep (
rg) onPATH, required bysearchandlist_files
The server exits loudly if any of these is missing; it never starts with a silently reduced tool surface.
Install
From a release asset (fastest, no build toolchain, no registry account):
npm install -g https://github.com/MatiasPujado/Project_Lens/releases/download/v0.4.0/mpujado-project-lens-0.4.0.tgznpm installs a tarball straight from a URL, so this needs no authentication and no registry configuration for the package itself. Its three runtime dependencies still resolve from whatever registry npm is already configured with. Check the releases page for the current version.
From source:
git clone https://github.com/MatiasPujado/Project_Lens.git && cd Project_Lens
npm ci
npm run build
npm link # optional: puts `project-lens` on PATHAs a tarball, for handing the built server to someone else:
npm run build && npm pack # writes mpujado-project-lens-<version>.tgz
npm install -g ./mpujado-project-lens-<version>.tgzThe package ships dist/src only (no tests, no benchmarks, no sources) and has three runtime dependencies
(@modelcontextprotocol/server, picomatch, zod). Verify with which project-lens and
npm ls -g @mpujado/project-lens; the binary takes no flags, so --version would be read as a workspace path and fail.
Point it at a workspace
The server needs one thing: a root directory to scan. Everything underneath it becomes groups and projects.
export PROJECT_LENS_PATH="$HOME/Projects"Precedence: positional CLI argument → PROJECT_LENS_PATH → roots in the config file. With none of them set, the
server exits with an error. The root must exist and be a directory (~ is expanded by the server).
Register with an agent
Transport is stdio, so every client needs the same three things: a command to spawn, the workspace root, and optionally an environment block. Any spec-compliant MCP client can drive the server, only the registration syntax differs.
claude mcp add project-lens -- project-lens "$PROJECT_LENS_PATH"Or in a config file, where ${VAR} expansion is supported:
{
"mcpServers": {
"project-lens": {
"type": "stdio",
"command": "project-lens",
"args": ["${PROJECT_LENS_PATH}"],
"env": {}
}
}
}In ~/.codex/config.toml:
[mcp_servers.project-lens]
command = "project-lens"
args = ["/absolute/path/to/workspace"]In ~/.gemini/settings.json:
{
"mcpServers": {
"project-lens": {
"command": "project-lens",
"args": ["/absolute/path/to/workspace"]
}
}
}{
"mcpServers": {
"project-lens": {
"type": "stdio",
"command": "project-lens",
"args": ["/absolute/path/to/workspace"],
"env": {}
}
}
}Pick command to match how you installed:
Install |
|
Global ( |
|
Into a project |
|
Clone, without |
|
Two things that commonly trip people up:
GUI clients often do not inherit your shell
PATH, so a bare"project-lens"can fail to spawn even when it works in a terminal. Use an absolute path there (which project-lensprints it).Environment-variable expansion inside config JSON is client-specific. If yours does not support it, pass the workspace root literally in
args, or set it in the server's own environment:"env": {"PROJECT_LENS_PATH": "/absolute/path"}.
Only needed for exclusion globs, multiple roots, or enabling writes. Location: $PROJECT_LENS_CONFIG if set, else
$XDG_CONFIG_HOME/project-lens/config.json, else ~/.config/project-lens/config.json. A missing file is fine; a
malformed one fails startup, and so does a root it lists that does not exist or is not a directory.
{
"roots": ["/absolute/path/to/workspace"],
"exclude": ["**/Archived*/**", "**/vendor/**"]
}Field | Type | Meaning |
|
| Absolute paths (or |
|
| Globs matched against root-relative paths; pruned before descent |
|
| Registers |
Excluding is worth doing: it shrinks the startup scan, the candidate set for every search, and every listing
response. The tradeoff is real, though: an excluded tree leaves the registry entirely, so its projects stop being
resolvable by name from every tool, not just from search.
A root can declare its own excludes in a .project-lens.json at its top level. This is the right place for them when
the workspace is shared across machines, or when the server is launched with a bare path and no global config file at
all:
{ "exclude": ["Archived/**"] }Its patterns are unioned with the global exclude, but only for that root. One root's excludes never apply to a
sibling.
exclude is the only key this file may set. It lives inside a workspace tree, which is content an untrusted
repository can author, so allow_writes and roots are ignored here on purpose: a cloned repository must not be able
to turn the write tools on or widen the scan. Set those in the global config file only. A malformed .project-lens.json
fails startup rather than being skipped.
write_file and scaffold_project are the only tools that mutate anything, and they are not registered unless you
turn them on:
export PROJECT_LENS_ALLOW_WRITES=1 # or 'true' / 'yes' / 'on'{ "roots": ["/absolute/path/to/workspace"], "allow_writes": true }The environment variable wins over the config file. Everything else the server exposes is read-only.
scaffold_project asks the user before it creates anything. It checks the name, the group and the target first, then
sends a form naming the exact path through MCP elicitation, and creates the project only on an explicit yes. A client
that cannot show the form, a decline, a cancel or a "no" creates nothing. Without group, the project goes straight
under a root (reported as group (root)); root names which one, and must resolve to a configured root as
map_workspace lists it: it is compared after path resolution, so a trailing slash is ignored and a relative path
resolves against the server's working directory.
Every tool declares MCP tool annotations: the read-only tools readOnlyHint: true, write_file destructiveHint: true
(it overwrites), scaffold_project readOnlyHint: false and destructiveHint: false (it never replaces anything), and
all of them openWorldHint: false.
Upgrading from 0.3
Version 0.4.0 changes behaviour a client or an operator may rely on:
project_infotakesproject, like every other per-project tool. A call that still passesnameis refused as invalid arguments.The configuration file moved. The server reads
$PROJECT_LENS_CONFIG, else$XDG_CONFIG_HOME/project-lens/config.json, else~/.config/project-lens/config.json.PROJECTS_MCP_CONFIG,$XDG_CONFIG_HOME/projects-mcp/config.jsonand~/.config/projects-mcp/config.jsonare no longer read, with no fallback: move the file or rename the variable.Every root in use is checked at startup. When the roots come from the configuration file, one that does not exist or is not a directory now fails startup; 0.3 checked only a command-line or
PROJECT_LENS_PATHroot.ripgrep ignores your ripgrep configuration.
searchandlist_filesstart it with--no-config, so a file named byRIPGREP_CONFIG_PATHno longer changes what they find.A project held by two roots is no longer resolved silently. When two roots hold the same
group/name, a call naming it fails as ambiguous and lists both absolute paths; pass one of them instead. 0.3 kept only one copy.scaffold_projectasks the user first. It needs a client that supports MCP form elicitation; without one, or without an explicit yes, nothing is created.list_projectsrejects an unknown group withUnknown group: "<group>"instead of returning no rows.Group filters ignore letter case in
list_projectsandsearch. When a group matches as written, only that one counts, soAIandaistay apart on a case-sensitive disk.More paths are refused.
read_file,write_file,searchandlist_filesrefuse any path with a.gitsegment, in any letter case, and every secret-pattern file. In 0.3write_filedid not check secret files at all, and the other three knew only.env*,*.pem,id_rsa*and*credentials*. The list now adds.npmrc,.netrc,.pgpass,.htpasswd,id_ed25519*,id_ecdsa*,id_dsa*, and the key and certificate stores*.key,*.p12,*.pfx,*.jks,*.keystoreand*.kdbx. A refusedrelative_pathorpath_prefixis reported asAccess forbidden (.git or secret-pattern file): <path>; a refused search hit or listed file is left out.write_filenever writes through a symbolic link in the last path component, even one that points inside the project; 0.3 followed it.read_filemarks partial reads. A read withoffsetorlimitends with[lines a-b of N]; anoffsetpast the end returns[offset a is past the last line, N]; a read that hits the size cap ends with[truncated at C chars in line L of N].aandbare the first and last line returned,Nthe file's line count,Cthe cap, 500000 characters, andLthe line the read stopped in.searchcaps each excerpt line at 300 characters. 0.3 capped the joined excerpt instead, so one long line could push the lines after it out.write_filerefuses every write on a platform withoutO_NOFOLLOW(Windows).is_cleanignores changes inside submodules: it reports the repository's own files only.is_cleanruns no filter the repository's own config defines.git statusruns with the clean, smudge and process commands of the repository's ownfilter.*entries blanked, so a repository that relies on such a filter can report a differentis_clean. Filters from your global or system config still run.core.fsmonitoris turned off too. When git cannot list the repository's config,is_cleanisnull, because runninggit statuscould run a filter.
For developers and contributors
src/ config, discovery, registry, git, search, security, stack, tools, server entry
test/ vitest suites, one per module, plus an in-process MCP integration suite
benchmark/ e2e latency, registry micro-benchmarks, token-cost harnessnpm run build # tsc
npm test # type-check src, test and benchmark, then vitest: unit + integration
npm run lint # eslint with typescript-eslint type-checked rules, tests included
npm run test:watch # watch mode
npm run test:coverage # coverage report
npm run inspector # manual acceptance via the MCP InspectorSetup, testing, benchmarking, commit conventions and how to submit a change are in CONTRIBUTING.md.
License
See LICENSE.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
A MCP server built for developers enabling Git based project management with project and personal…
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
An MCP server that gives your AI access to the source code and docs of all public github repos
Capability registry for the agentic economy. Semantic search over verified MCP server listings.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server that gives AI agents deep code understanding across multiple git repositories, combining git lifecycle management, Zoekt-based trigram code search, and cross-repo dependency analysis.MIT
- AlicenseNot gradedqualityCmaintenanceA read-only MCP server that provides AI agents with live, structured workspace awareness, including project listing, git status, and budgeted context packing, minimizing token usage.10 npm2MIT
- FlicenseNot gradedqualityDmaintenanceWorkspace-aware MCP server that provides AI clients with structural code understanding via AST parsing, hybrid retrieval, and git history, enabling accurate code search, definition lookup, and blame analysis.-
- AlicenseNot gradedqualityCmaintenanceA production-ready MCP server that enables AI assistants to intelligently understand, analyze, edit, navigate, and review software projects with multi-workspace support, Git integration, and semantic search.1MIT