myopic
This server is a code-review MCP tool that reviews GitLab merge requests and GitHub pull requests against the whole codebase, not just the diff, with read-only analysis and one optional write tool.
Read MR metadata and status:
mr_review_statusreturns MR info, discussions, resolved/unresolved threads, commits, and file-change summary.List changed files cheaply:
mr_changed_filesgives file paths, stats, and reviewability flags without diff content.Fetch diffs token-safely:
mr_diff_linesreturns line-numbered hunks;mr_diff_sectionsgroups changes by function/class; both bound output and list omitted/skipped files.Analyze dependency impact:
dependency_impactfinds every usage of a changed symbol via ripgrep + tree-sitter.Trace call graphs:
trace_call_chainmaps a symbol's callers and callees to understand ripple effects.Get review context per changed symbol:
mr_review_contextruns dependency impact on top symbols and optionally adds semantically similar code from the codebase.Semantic code search:
index_repobuilds/incrementally refreshes a local LanceDB index;index_statusreports freshness;code_searchdoes hybrid vector + full-text search.Verify whether review comments were addressed:
mr_verify_reviewchecks nearby diff changes for each discussion thread.Post inline comments (the only write):
mr_post_commentsposts comments one at a time with backoff, only on explicit user request.
Reviews GitHub pull requests, reads the change, reviews against the whole codebase, and posts inline comments.
Reviews GitLab merge requests, reads the change, reviews against the whole codebase, and posts inline comments.
Provides semantic code search using a local Ollama server with an embedding model, enabling similarity-based code retrieval and review context enrichment.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@myopic review merge request https://gitlab.com/owner/repo/-/merge_requests/1"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
myopic
The code-review MCP with the most ironic name in the registry. It's anything but nearsighted — it reviews your merge request against the whole codebase, not just the diff in front of it.
Building in public. Reviews GitLab merge requests and GitHub pull requests — pass either URL. Reads the change, reviews it against the whole codebase, and can post the review back as inline comments. Issues and PRs welcome.
Why
The bugs that matter rarely live in the diff. They live in what it doesn't show: the caller three files away that now breaks, the convention every sibling file follows that this one quietly drops, the helper that already exists so this new one is a duplicate. A reviewer that only reads the patch is myopic.
myopic is an open-source MCP server that gives the AI client you already use (Claude, Cursor, …) the structured context to review like someone who knows the codebase. It runs on your machine — your code never leaves it, there's no per-PR bill, and the review happens in your own agent with your own standards:
Read the change precisely — the diff as line-numbered hunks or grouped by function/class, token-safe on any MR size (a 10,000-line diff never overflows the context window).
Review it against the whole codebase — who calls the changed code (blast radius), the caller/callee graph, and — optionally — semantically similar code so you catch broken conventions and duplication.
It pairs with amnesic, my MCP server that gives AI persistent memory of SQL databases.
Related MCP server: grippy-code-review
Tools
Everything below works today unless marked planned.
Read the merge request (token-safe by construction):
Tool | What it does |
| MR metadata + every discussion thread + resolved/unresolved, in one call |
| a content-free manifest of changed files (paths, stats, noise flags) — no diff content, so it stays small even on a huge MR |
| the diff grouped by function/class (AST-aware), budget-bounded |
| the diff as line-numbered hunks — exact positions for inline comments — budget-bounded |
On a large MR, the diff tools return a bounded page and list the rest under
omitted_files / truncated instead of failing; lockfiles, generated code, and
binaries are listed but not expanded. Fetch the rest with files_filter.
Review against the whole codebase (point at a local clone):
Tool | What it does |
| everywhere a changed symbol is used — the blast radius (ripgrep + tree-sitter) |
| the caller/callee graph of a symbol |
| the headline — for each changed symbol: its impact (always), plus semantically similar code when the optional layer is enabled |
Semantic layer (built in — needs Ollama) — index_repo, code_search,
and the semantic half of mr_review_context. See below.
Close the loop — verify, and (on request) comment:
Tool | What it does |
| for each existing review thread, the diff changes near the commented line — did a follow-up commit address it? (read-only) |
| the one write — post inline comments, one at a time from a queue with exponential backoff (no drafts, no bulk-publish), so partial progress survives and rate limits are respected |
See ROADMAP.md for what's next.
Install
pipx installs myopic isolated and on your PATH:
pipx install myopicPrefer a plain venv? python3 -m venv ~/.venvs/myopic && ~/.venvs/myopic/bin/pip install myopic, then use that binary where the examples say myopic.
Setup
myopic needs a personal access token with api (or read_api) scope. The wizard
walks you through it:
myopic init # prompts for URL + token, verifies, saves both
myopic test # ✓ Authenticated to https://gitlab.com as <you>
myopic doctor # health-check config + (if enabled) the semantic layerThe token is saved to ~/.config/myopic/.env (chmod 600) and referenced from the
TOML as ${GITLAB_TOKEN} — never in the config file itself. Rotate it with
myopic set-secret, or hand-edit via myopic init --template.
GitHub PRs: just pass a PR URL. Set a GITHUB_TOKEN (a PAT with
pull-request read access) in your environment or a [github] section in
config.toml. For GitHub Enterprise, set [github].url to your host.
Add to your AI client
Claude Code — one command, no config editing:
/plugin marketplace add https://github.com/SurajKGoyal/myopic-marketplace
/plugin install myopic@myopicAny other MCP client (Cursor, Claude Desktop, …) — point it at the myopic
command:
{
"mcpServers": {
"myopic": {
"command": "myopic"
}
}
}If your client can't find it on PATH, use the absolute path (pipx installs to
~/.local/bin/myopic).
Configure inline instead of myopic init
Put the token in the env block and skip the config file — myopic reads
GITLAB_TOKEN / GITHUB_TOKEN from the environment:
{
"mcpServers": {
"myopic": {
"command": "myopic",
"env": { "GITLAB_TOKEN": "glpat-…", "MYOPIC_AUTO_PULL": "1" }
}
}
}MYOPIC_AUTO_PULL=1 (optional) pulls a missing embedding model on first use
instead of erroring.
Use
Point your AI at a merge request:
"Review this MR: https://gitlab.com/group/project/-/merge_requests/42"
A good flow the client can follow: mr_changed_files to see the shape →
mr_diff_sections (large MRs) or mr_diff_lines to read the change → then, with
a local clone checked out, dependency_impact / trace_call_chain (or
mr_review_context) on the risky changed symbols to review against everything
that depends on them.
The graph tools analyze whatever is checked out at root, so check out the MR's
branch first — otherwise you're reviewing the target branch, and the MR's new
code isn't there. myopic worktree <mr-url> <repo> checks out the MR head in a
throwaway worktree (your main checkout untouched) and prints the path to use as
root. mr_review_context also warns when root doesn't hold the MR's head.
Fork PRs work too: a fork's branch doesn't exist on your remote, so GitHub PR
heads are fetched via refs/pull/N/head, which the base repository serves
whether the PR came from a branch or a fork.
Semantic search (built in — needs Ollama)
For "is this consistent with the rest of the codebase?" — duplication, convention drift, similar patterns — the semantic layer covers it. It's bundled in the base install (lancedb + httpx); the only external requirement is a running Ollama.
Embeddings come from a local Ollama server you run — your code never leaves your machine. myopic talks to Ollama over HTTP; it does not bundle or launch it. The one-time prerequisites:
Ollama running (default
localhost:11434, or setMYOPIC_OLLAMA_URL).The embedding model pulled:
ollama pull unclemusclez/jina-embeddings-v2-base-code.
myopic doctor checks both and offers to pull the model for you.
Embeddings are stored in an embedded LanceDB index with
hybrid (vector + full-text) search, and mr_review_context enriches each changed
symbol with semantically similar code. You don't run index_repo by hand —
it indexes the repo on the first review and refreshes when stale, automatically
(disable with MYOPIC_AUTO_INDEX=0; the graph pass needs no index and always
runs). index_repo / myopic index remain for explicit/cron use.
Indexing is incremental and freshness-aware. The first index_repo is a full
build; after that only files whose content changed are re-embedded, so refreshing
is cheap. index_status(root) reports whether the index is fresh, stale (with
how many commits behind main), or built on a different model — freshness is
measured against the repo's main line, not the current checkout, so reviewing
a feature branch never marks the index stale; only main actually moving does.
code_search and
mr_review_context carry that status so a stale index never silently degrades a
review; the AI is told to offer a refresh when it's stale.
The index is per repository, not per checkout — a myopic worktree at an MR's
head shares its clone's index, so reviewing a new branch never rebuilds it; only
the files that branch changed get re-embedded.
A separate clone of the same repo does get its own index, and a repo you delete leaves one behind. Indexing drops such dead copies automatically; to review and reclaim them yourself:
myopic prune # dry-run: what's stale, and how much it's costing
myopic prune --apply # delete themA second clone you still use keeps its index — only unreachable ones are removed.
myopic is a stdio server (no background process), so there's no built-in
scheduler — but myopic index /path/to/repo is the hook for one. Point cron or
launchd at it to keep an index fresh out of band:
# refresh hourly (incremental — usually seconds)
0 * * * * myopic index /path/to/repoOverride the model/endpoint with MYOPIC_EMBED_MODEL / MYOPIC_OLLAMA_URL.
Configuration reference
Source | Key | Notes |
|
| GitLab base URL (default |
|
| use |
|
| the actual token value (chmod 600) |
env var |
| fallback if no TOML |
env var |
| fallback if no TOML |
env var |
| override the config file / directory |
env var |
| semantic layer model + endpoint |
env var |
|
|
env var |
|
|
Security
One explicit write, everything else read-only. Only
mr_post_commentsmutates a review, and only when you ask for it — every other tool just reads MR and repo data. The write is never speculative.Your token stays local. It lives in your
.env/ environment and is sent only to your configured GitLab instance — never to any third party.Auth errors are scrubbed so your token never leaks into error messages.
The semantic layer runs entirely locally (your Ollama, an on-disk index) — your code is never sent to a third party.
Development
pip install -e ".[dev]"
pytest # hermetic — no network, Ollama, or lancedb neededLicense
MIT © Suraj Goyal
mcp-name: io.github.SurajKGoyal/myopic
Available Tools
12 toolscode_searchA
Hybrid semantic + full-text search over an indexed local repository.
Embeds the query via Ollama, then runs a combined vector + FTS search with RRF reranking against the LanceDB index built by index_repo. Use this to find existing patterns, conventions, or examples in the codebase before reviewing a new implementation. Requires a running Ollama (the semantic layer is built in) and index_repo to have been run first.
Args: query: Natural language or code snippet describing what to find. root: Absolute path to the repository (must have been indexed first). k: Maximum number of results to return (default 8).
Returns: {query, root, results[{file_path, symbol, symbol_type, start_line, end_line, text, score?}]} or {"error": "..."} on failure.
Inputs: root (required), query (required), k.
dependency_impactA
Find everywhere a symbol is used in a checked-out repo (the blast radius).
The highest-value review signal: before you approve a change to a function, class, or constant, see who depends on it. Uses ripgrep for fast candidate finding, then classifies each usage via tree-sitter AST as call / import / definition / type_reference. Filesystem-based — point it at a LOCAL clone of the repo the MR belongs to, not the MR URL.
Args: symbol: Function/class/variable name to trace. root: Absolute path to the local repository clone. file_glob: Optional glob to narrow the search (e.g. ".py", "src/**/.ts"). whole_word: Match whole words only (default True). max_results: Cap on references returned (default 50).
Returns: {symbol, root, total_references, references[{file_path, line, context, usage_type}], by_type{...}}
Inputs: root (required), symbol (required), file_glob, whole_word, +1 more.
index_repoA
Build or incrementally refresh a semantic search index for a local repository.
Walks the repo, chunks every supported-language file by AST boundaries,
embeds the chunks via a local Ollama server, and stores them in a per-repo
LanceDB table. After the first build this is INCREMENTAL: only files whose
content changed since the last run are re-embedded, so refreshing is cheap —
run it freely (e.g. when index_status reports "stale"). A changed embedding
model or force=True does a full rebuild. Requires a running Ollama (the
semantic layer is built in; run myopic doctor to set it up) at
MYOPIC_OLLAMA_URL (default http://localhost:11434) with the
model pulled (MYOPIC_EMBED_MODEL).
Args: root: Absolute path to the repository to index. force: Rebuild the whole index even if an up-to-date one exists.
Returns: {mode, indexed_chunks, files, skipped, changed_files, deleted_files, git_sha, model} on success, or {"error": "..."} on failure.
Inputs: root (required), force.
index_statusA
Report whether a repo's semantic index is fresh, stale, or absent.
Freshness is keyed to the git commit the index was built from — if HEAD has moved on, the index is "stale" and reports how many commits behind. Check this before leaning on semantic results (code_search / mr_review_context): if state is "stale" or "model_mismatch", offer to index_repo(root) first.
Args: root: Absolute path to the repository.
Returns: {state: absent|fresh|stale|model_mismatch|unknown, root, chunks?, indexed_at?, indexed_sha?, current_sha?, commits_behind?, reason?} or {"error": "..."} if the semantic extra is not installed.
Inputs: root (required).
mr_changed_filesA
List the files changed in a merge request with stats — no diff content.
The cheap entry point for large reviews: the payload has no diff content, so it stays small even on a very large MR. Each file reports additions/deletions, new/deleted/renamed flags, and a reviewability flag (lockfiles, generated code, binary assets, and enormous single-file changes are marked reviewable=false with a skip_reason). Files are ordered reviewable-first then largest-change-first, so you can batch the highest-value files straight into mr_diff_lines(url, files_filter=[...]).
Args: url: Full GitLab merge request URL.
Returns: {mr_number, title, author, branches, commits, diff_shas, files[{file_path, additions, deletions, reviewable, skip_reason, ...}], stats{total_files, reviewable_files, skipped_files, ...}}
Inputs: url (required).
mr_diff_linesA
Fetch a merge request's diff as structured, line-numbered hunks.
Pure data, no LLM. Returns exact file paths, old/new line numbers, and diff content — everything needed to read a change precisely and to compute the diff positions required for inline comments.
Token-safe by construction: on a large MR it returns a bounded page of files and lists the rest under "omitted_files" with "truncated": true (never an oversized payload). Noise files (lockfiles, generated, binary) are listed under "skipped_files", not expanded. For unknown-size MRs, call mr_changed_files first, then batch files_filter here.
Args: url: Full GitLab merge request URL. files_filter: Optional list of file-path fragments to include. Passing this is a TARGETED fetch — noise-skip and the budget are disabled so you get exactly the files you ask for. lines_filter: Optional map of filename-fragment -> target new-file line numbers; returns compact line_mappings instead of full hunks. max_chars: Token-safety budget for the returned diff body (default 80000). Ignored for targeted fetches. skip_noise: Keep lockfiles/generated/binary out of the body (listed under skipped_files). Default True. Ignored when filtering.
Returns: {mr_number, ..., diff_shas, files[...], truncated, omitted_files, skipped_files, stats}
Inputs: url (required), max_chars, skip_noise, files_filter, +1 more.
mr_diff_sectionsA
Fetch a merge request's diff grouped by enclosing function/class, not raw hunks.
AST-aware for new files (full tree-sitter chunking) and hunk-context-aware for modified files (declaration pattern + hunk-header hint). All changed lines (add/del) are always included — nothing dropped, only the framing changes. Prefer this over mr_diff_lines on a large MR (many files or a big diff) since grouping by symbol keeps the payload small without truncating mid-function.
Token-safe by construction, same guarantees as mr_diff_lines: on a large MR it returns a bounded page of files and lists the rest under "omitted_files" with "truncated": true. Noise files (lockfiles, generated, binary) are listed under "skipped_files", not expanded. For unknown-size MRs, call mr_changed_files first, then batch files_filter here.
Args: url: Full GitLab merge request URL. include_context_lines: Include unchanged surrounding lines in each section. Default False keeps the payload small. files_filter: Optional list of file-path fragments to include. Passing this is a TARGETED fetch — noise-skip and the budget are disabled so you get exactly the files you ask for. max_chars: Token-safety budget for the returned diff body (default 80000). Ignored for targeted fetches. skip_noise: Keep lockfiles/generated/binary out of the body (listed under skipped_files). Default True. Ignored when filtering.
Returns: {mr_number, title, author, branches, description, commits, diff_shas, files[{file_path, language, new_file, deleted_file, additions, deletions, sections[{symbol, symbol_type, start_line, end_line, changes}]}], truncated, omitted_files, skipped_files, stats}
Inputs: url (required), max_chars, skip_noise, files_filter, +1 more.
mr_post_commentsA
Post inline review comments to a merge/pull request. WRITE — this mutates the review.
The only mutating tool in myopic. Posts each comment one at a time from a queue, immediately visible (no drafts, no bulk-publish), retrying transient failures (HTTP 429/5xx) with exponential backoff — so partial progress survives a failure and self-hosted rate limits are respected. Works on GitLab and GitHub; the backend translates positions. Only call this on the user's explicit request to post — never speculatively.
Get exact line numbers first from mr_diff_lines (its lines_filter maps a source line to the diff position). Each comment needs file_path, body, and at least one of new_line (added/unchanged line) or old_line (removed line).
Args: url: Full merge/pull request URL. comments: List of {file_path, body, new_line?, old_line?, old_path?}. max_comments: Safety cap per call (default 25); split larger batches.
Returns: {url, platform, total, posted, failed, published, publish_error, details[{file_path, line, status, error}]} or {"error": "..."}.
Inputs: url (required), comments (required), max_comments.
mr_review_contextA
Graph-first review context: dependency impact per changed symbol, plus optional semantic enrichment.
Extracts the top-N most-frequent identifiers from the MR diff, then for each:
Runs dependency_impact(symbol, root) — always, no optional extras needed.
If the repo has been indexed via index_repo(root), enriches each symbol with related_patterns from a hybrid semantic search against the codebase.
The semantic layer is purely additive: a result with semantic_available=false is complete and actionable — dependency impact already covers the blast radius. Use this as a single-call alternative to running dependency_impact separately for each changed symbol.
Args: url: Full GitLab merge request URL. root: Absolute path to the local repository clone. max_symbols: Maximum changed symbols to analyze (default 8).
Returns:
{mr_number, symbols[{symbol, impact, related_patterns?}], symbol_source,
semantic_available, root_status?, warning?, index_status?} or
{"error": "..."}. A "warning" means root isn't checked out to the MR —
set it up with myopic worktree <url> <repo> and re-run against its path.
Inputs: url (required), root (required), max_symbols.
mr_review_statusA
Get a merge request's review status: metadata + discussions + resolution.
Pure data, no LLM. Collapses several platform API calls into one snapshot of where the review stands — every discussion thread, what's resolved vs open, general comments, and a lightweight file-change summary. Start here to orient before diving into the diff.
Args: url: Full GitLab merge request URL.
Returns: {mr_number, title, author, branches, state, merge_status, commits, general_comments, discussions[...], summary{resolved, unresolved, ...}, files_changed[...], stats}
Inputs: url (required).
mr_verify_reviewA
Check whether each review thread was addressed by nearby diff changes.
Joins the review's discussions with its current diff: for every inline comment thread, surfaces the add/del lines within +/-window of the commented line. A thread with no nearby changes is a candidate for "not yet addressed"; one with changes shows exactly what moved near it — a fast re-review pass without re-reading the whole diff. Read-only. Works on GitLab and GitHub (note: GitHub doesn't expose thread resolution via REST, so rely on has_changes there, not the resolved flag).
Args: url: Full merge/pull request URL. window: Lines before/after the commented line to scan (default 40).
Returns: {mr_number, title, summary{total_threads, resolved, unresolved, threads_with_changes, threads_without_changes}, threads[{..., nearby_changes, has_changes}], threads_no_location[...]}
Inputs: url (required), window.
trace_call_chainA
Trace a function's callers and callees across a checked-out repo (AST).
Complements dependency_impact: where dependency_impact lists every reference, this builds the directed call graph — where the symbol is defined, what it calls, and what calls it — so you can reason about a change's ripple effects. Tree-sitter-based; point it at a LOCAL clone of the repo.
Args: symbol: Function or class name to trace. root: Absolute path to the local repository clone. language: Restrict to one language; auto-detects if omitted. max_depth: Levels of callers/callees to follow (default 1).
Returns: {symbol, definition{file_path, line, type}, callees[...], callers[...], stats{files_scanned, parse_errors}}
Inputs: root (required), symbol (required), language, max_depth.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 12 tools
Every tool has a clearly distinct purpose: MR summary, raw diff vs. sectioned diff, review status, thread verification, comment posting, and separate local analysis tools (dependency_impact, trace_call_chain, code_search). Even the two diff tools are explicitly differentiated by structured sections vs. raw hunks, with guidance on when to prefer each.
Tool names are mostly predictable: MR-related tools share the `mr_` prefix, and indexing tools share `index_`. However, the underlying verb/noun pattern is not fully uniform (e.g., `code_search` vs. `index_repo`, `mr_diff_sections` vs. `mr_verify_review`), though all names are descriptive and support quick recognition.
12 tools is well-scoped for a code review assistant. Each tool covers a distinct step: changed-file summary, diff variants, review status, verification, posting, and local repository analysis (dependency, call graph, semantic search). No tool feels redundant or missing.
The tool set covers the full MR review lifecycle—orient (mr_changed_files, mr_review_status), inspect (mr_diff_lines, mr_diff_sections), analyze impact (dependency_impact, trace_call_chain, mr_review_context), verify threads (mr_verify_review), and act (mr_post_comments). Local indexing and search tools round out the surface, leaving no obvious dead ends.
Maintenance
Related MCP Connectors
AI-native git hosting — repos, PRs, issues, CI gates, and AI code review over MCP (60 tools).
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
One MCP server for all your MCP servers: code mode, per-tool permissions, approvals and audit.
A MCP server built for developers enabling Git based project management with project and personal…
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that automates code reviews through linting, testing, and git diff analysis. It also generates conventional commit messages and detailed pull request descriptions based on file changes and code patterns.ISC
- AlicenseNot gradedqualityCmaintenanceOpen-source AI code review MCP server for local git diff auditing with deterministic security rules and AI-powered analysis using any OpenAI-compatible model.4MIT
- AlicenseAqualityDmaintenanceAn MCP server that performs automated code reviews by analyzing git diffs against configurable review standards with custom reviewer personas.72MIT
- AlicenseNot gradedqualityDmaintenanceMCP server for automated code review using AI agents. It analyzes code diffs or file paths for bugs, security issues, and style violations.MIT