Skip to main content
Glama

myopic

PyPI version Python License: MIT MCP Registry

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_review_status

MR metadata + every discussion thread + resolved/unresolved, in one call

mr_changed_files

a content-free manifest of changed files (paths, stats, noise flags) — no diff content, so it stays small even on a huge MR

mr_diff_sections

the diff grouped by function/class (AST-aware), budget-bounded

mr_diff_lines

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

dependency_impact

everywhere a changed symbol is used — the blast radius (ripgrep + tree-sitter)

trace_call_chain

the caller/callee graph of a symbol

mr_review_context

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

mr_verify_review

for each existing review thread, the diff changes near the commented line — did a follow-up commit address it? (read-only)

mr_post_comments

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 myopic

Prefer 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 layer

The 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@myopic

Any 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:

  1. Ollama running (default localhost:11434, or set MYOPIC_OLLAMA_URL).

  2. 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 them

A 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/repo

Override the model/endpoint with MYOPIC_EMBED_MODEL / MYOPIC_OLLAMA_URL.


Configuration reference

Source

Key

Notes

config.toml

[gitlab].url

GitLab base URL (default https://gitlab.com)

config.toml

[gitlab].token

use ${GITLAB_TOKEN} — don't hardcode

.env (next to config)

GITLAB_TOKEN

the actual token value (chmod 600)

env var

MYOPIC_GITLAB_URL / GITLAB_URL

fallback if no TOML

env var

MYOPIC_GITLAB_TOKEN / GITLAB_TOKEN

fallback if no TOML

env var

MYOPIC_CONFIG / MYOPIC_HOME

override the config file / directory

env var

MYOPIC_EMBED_MODEL / MYOPIC_OLLAMA_URL

semantic layer model + endpoint

env var

MYOPIC_AUTO_INDEX

0 to disable auto-indexing during review (default on)

env var

MYOPIC_AUTO_PULL

1 to auto-pull a missing embedding model on first use (default off)

Security

  • One explicit write, everything else read-only. Only mr_post_comments mutates 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 needed

License

MIT © Suraj Goyal

mcp-name: io.github.SurajKGoyal/myopic

Available Tools

12 tools
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:

  1. Runs dependency_impact(symbol, root) — always, no optional extras needed.

  2. 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

    A4.7/5.0

    Scored across 12 tools

    Disambiguation5/5

    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.

    Naming Consistency4/5

    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.

    Tool Count5/5

    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.

    Completeness5/5

    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

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers