roslyn-codelens-mcp
A Roslyn-based MCP server that gives AI agents deep semantic understanding of .NET solutions — navigation, call graphs, diagnostics, testing gaps, code quality audits, and solution-wide refactoring with preview/apply.
Navigate code:
go_to_definition,find_references(tagged by kind: read/write/invocation/etc.),search_symbols,get_method_source,get_type_hierarchy,find_implementations,find_callers,get_call_graph,get_overloads,get_extension_methods,get_operators,get_symbol_contextUnderstand types:
get_type_overview,get_instantiation_options,get_file_overview,analyze_method,get_di_registrations,get_public_api_surfaceAnalyze exceptions & events:
get_exception_flow,find_throw_sites,find_catch_blocks,find_event_subscribers,resolve_stack_trace,analyze_data_flow,analyze_control_flowTest coverage:
find_tests_for_symbol,get_test_summary,find_uncovered_symbols,generate_test_skeletonCode quality audits (with configurable thresholds):
get_complexity_metrics,find_large_classes,find_god_objects,find_unused_symbols,find_naming_violations,find_async_violations,find_disposable_misuse,find_reflection_usage,find_obsolete_usage,find_attribute_usages, compositeget_project_healthArchitecture governance:
check_architecture(forbid/allowOnly layering rules),find_circular_dependencies,get_project_dependencies,get_nuget_dependencies,find_breaking_changes,analyze_change_impactRefactor safely:
rename_symbol,change_signature,get_code_actions,apply_code_action,get_code_fixes(all with preview-before-write)Diagnostics & generated code:
get_diagnostics,get_source_generators,get_generated_codeExternal assemblies:
inspect_external_assembly,peek_ilfor closed-source NuGet packagesSolution management:
list_solutions,set_active_solution,load_solution,unload_solution,rebuild_solution, background tasks (start_background_task,get_task_status,list_running_tasks)Security/trust:
trust_solution,list_trusted_paths,revoke_trustto gate analyzer executionUniform responses: list tools return
items/totalCount/truncated/limit/summary; errors return structuredcode/message/detailsand support cancellation
Provides deep semantic analysis of .NET codebases, allowing for the exploration of type hierarchies, call graphs, dependency injection registrations, diagnostics, and automated code fixes.
Enables the inspection and listing of NuGet package dependencies and references across projects within a .NET solution.
Roslyn CodeLens MCP Server
A Roslyn-based MCP server that gives AI agents deep semantic understanding of .NET codebases — type hierarchies, call graphs, DI registrations, diagnostics, refactoring, and more.
Hosted deployment
A hosted deployment is available on Fronteir AI.
Related MCP server: solograph
Features
find_implementations — Find all classes/structs implementing an interface or extending a class
find_callers — Find every call site for a method, property, or constructor
find_event_subscribers — Every += / -= site for an event symbol, with resolved handler and subscribe/unsubscribe tag
find_tests_for_symbol — List xUnit/NUnit/MSTest methods that exercise a production symbol; opt-in transitive walk through helpers
get_test_summary — Per-project inventory of test methods with framework, attribute kind, data-row count, location, and production symbols referenced
find_uncovered_symbols — Public methods and properties no test transitively reaches; sorted by cyclomatic complexity for prioritization
generate_test_skeleton — Emit a compilable test-class skeleton (as text) for a method or type. Auto-detects xUnit/NUnit/MSTest; surfaces constructor dependencies as TodoNotes; returns a suggested file path. Closes the loop with
find_uncovered_symbolsget_type_hierarchy — Walk base classes, interfaces, and derived types
get_di_registrations — Scan for DI service registrations. Reads generic (
AddSingleton<IFoo, Foo>()), single-generic,typeofpair and factory-lambda formsget_instantiation_options — "How do I construct this type?" in one call: constructors with full parameter detail, static factory methods declared anywhere in the solution (including on a separate factory type), DI registrations, and
requiredmembers. PassfromProjectto learn whether that project can actually reach each option — it honoursInternalsVisibleTo, so it answers "can my test project call this internal constructor?"get_project_dependencies — Get the project reference graph
get_symbol_context — One-shot context dump for any type
get_public_api_surface — Enumerate every public/protected type and member in production projects; flat, deterministically-sorted list suitable for API review or breaking-change baselines.
find_breaking_changes — Diff the current API against a baseline JSON or DLL; report removed members, kind changes, and accessibility changes with Breaking/NonBreaking severity.
find_reflection_usage — Detect dynamic/reflection-based usage
get_exception_flow — What exceptions can escape a method: walks callees depth-bounded, propagates each throw up through every enclosing try/catch, and reports what still escapes with its propagation path; metadata callees contribute their documented exceptions
find_throw_sites — Every place an exception type is thrown, optionally including derived types; rethrows flagged
find_catch_blocks — Every catch for a type, optionally via base clauses; flags filtered, rethrowing, and empty (swallowing) handlers
find_references — Find all references to any symbol (types, methods, properties, fields, events), each tagged with a kind (
read,write,readwrite,invocation,method_group,object_creation,cast,type_check,typeof,base_type,type_constraint,type_argument,declaration,attribute,nameof,xml_doc) and reported per occurrence with a column; filter server-side withkinds(e.g.["write","readwrite"]for mutation sites)go_to_definition — Find the source file and line where a symbol is defined
get_method_source — Full declaration source (XML docs, attributes, signature, body — original formatting) for one or many members by name in a single call: methods (all overloads), constructors, properties, indexers, fields, events; per-item statuses (
ok/notFound/ambiguous/metadata/unsupportedKind) so a batch never fails wholesaleresolve_stack_trace — Map a pasted .NET stack trace to file/line/symbol, undoing compiler name mangling (async/iterator state machines, lambdas, local functions, generic arity); handles inner-exception chains, log-prefixed lines, and Demystifier traces
get_diagnostics — List compiler errors, warnings, and Roslyn analyzer diagnostics
get_code_fixes — Get available code fixes with structured text edits for any diagnostic
search_symbols — Fuzzy workspace symbol search by name
get_nuget_dependencies — List NuGet package references per project
find_attribute_usages — Find types and members decorated with a specific attribute
find_obsolete_usage — Every
[Obsolete]call site grouped by deprecation message and severity, errors first; for planning migrationsfind_circular_dependencies — Detect cycles in project or namespace dependency graphs
check_architecture — Enforce layering rules you supply (
forbidandallowOnly) against the real semantic type graph rather thanusingdirectives; violations are grouped per boundary with a reference count and example sitesget_complexity_metrics — Cyclomatic complexity, cognitive complexity and max nesting depth per member (methods, constructors, properties, indexers, operators). Cyclomatic counts paths and starts at 1; cognitive measures how hard the code is to follow and starts at 0.
metricpicks which one the threshold and sort use — cognitive is the better refactoring-priority signal, cyclomatic the better test-budget onefind_naming_violations — Check .NET naming convention compliance
find_async_violations — Sync-over-async,
async voidmisuse, missing awaits, fire-and-forget tasks; per-violation report with severityfind_disposable_misuse —
IDisposable/IAsyncDisposableinstances not wrapped inusing/await using/returned/assigned to field; severity error/warning per violation.find_large_classes — Find oversized types by member or line count
find_god_objects — Types combining high size with high cross-namespace coupling; sharper signal than raw size for SRP violations
find_unused_symbols — Dead code detection via reference analysis. Auto-filters test methods (xUnit/NUnit/MSTest), MCP tool entry points, source-generator output, MEF-composed services, and interop-laid-out fields; filter counts surface in
summary.filteredOutget_project_health — Composite audit aggregating 7 quality dimensions per project (complexity, large classes, naming, unused symbols, reflection, async violations, disposable misuse) with counts and top-N hotspots inline
get_source_generators — List source generators and their output per project
get_generated_code — Inspect generated source code from source generators
inspect_external_assembly — Browse types, members, and XML docs from closed-source NuGet packages and referenced assemblies
peek_il — Decompile any method to ilasm-style IL bytecode from closed-source or generated assemblies
get_code_actions — Discover available refactorings and fixes at any position (extract method, rename, inline variable, and more)
apply_code_action — Execute any Roslyn refactoring by title, with preview mode (returns a diff before writing to disk)
rename_symbol — Solution-wide safe rename of a type or member via Roslyn's Renamer, with preview mode, conflict reporting, and a freshness check against on-disk edits
change_signature — Add, remove, and reorder the parameters of a method or constructor, a positional record's primary constructor included, and rewrite every call site; handles named/optional arguments,
paramsand extension methods, reports the overrides and interface implementations it cascaded to, and warns about record properties, deconstructions and positional patterns the rewrite does not reachlist_solutions — List all loaded solutions and which one is currently active
set_active_solution — Switch the active solution by partial name (all subsequent tools operate on it)
load_solution — Load an additional .sln/.slnx at runtime and make it the active solution
unload_solution — Unload a loaded solution to free memory
rebuild_solution — Force a full reload of the analyzed solution
start_background_task — Queue a long-running tool (currently
rebuild_solution) to run in the background; returns ataskIdto pollget_task_status — Get the current status, result, or error of a background task by its
taskId. OptionalwaitSeconds(default 0, capped at 50) waits on the server until the task finishes instead of pollinglist_running_tasks — List background tasks running or completed within the last 5 minutes
trust_solution — Authorize a solution to run Roslyn analyzers (required before
get_diagnosticswithincludeAnalyzers: true)list_trusted_paths — Inspect the persistent trust store + session-trusted solutions
revoke_trust — Revoke a previously-granted trust for a solution path
analyze_data_flow — Variable read/write/capture analysis within a statement range (declared, read, written, always assigned, captured, flows in/out)
analyze_control_flow — Branch/loop reachability analysis within a statement range (start/end reachability, return statements, exit points)
analyze_change_impact — Show all files, projects, and call sites affected by changing a symbol — combines find_references and find_callers
get_type_overview — Compound tool: type context + hierarchy + file diagnostics in one call
analyze_method — Compound tool: method signature + callers + outgoing calls in one call
get_overloads — Every overload of a method/constructor (source + metadata) with full parameter and modifier detail in one call
get_extension_methods — Every extension member applicable to a type — including arrays, nullables and tuples — from the solution and referenced assemblies (so LINQ shows up), using Roslyn's own applicability rules; covers C# 14
extensionblocks including properties and static membersget_operators — Every user-defined operator and conversion operator on a type (source + metadata) with kind, signature, parameters, and source location. Includes synthesized record equality and .NET 7+ checked variants
get_call_graph — Transitive caller/callee graph for a method, depth-bounded with cycle detection
get_file_overview — Compound tool: types defined in a file + file-scoped diagnostics in one call
Response shape
All list-returning tools wrap their results in a uniform envelope:
{
"items": [ ... ],
"totalCount": 142,
"truncated": false,
"limit": 500,
"summary": { ... }
}When truncated is true, the items are the top N by the tool's natural sort order (severity-first, worst-first, by-project, etc.) — usually that's exactly what you want. Raise limit only if the missing tail items matter for the task.
Tools that include a summary aggregate today:
get_diagnostics—{ error, warning, info, hidden }countsfind_references—{ byProject: { name: count }, byKind: { kind: count } }find_callers,find_attribute_usages—{ byProject: { name: count } }search_symbols,find_reflection_usage—{ byKind: {...} }find_unused_symbols—{ byKind, filteredOut: { testMethod, testContainer, mcpTool, generated, composition, interop } }find_naming_violations—{ byRule: {...} }get_complexity_metrics—{ max, avg, overThreshold, maxCognitive }(the first three describe the selectedmetric)
Single-object tools (get_type_overview, get_symbol_context, apply_code_action, etc.) return their bespoke shape directly — the envelope only wraps list-returning tools.
Error responses
When a tool can't proceed (symbol not resolved, solution not trusted, file not found, ambiguous match, etc.), the response is an isError: true content block carrying a structured JSON body:
{
"code": "SolutionNotTrusted",
"message": "Solution 'Foo.sln' is not trusted for analyzer execution. ...",
"details": { "solutionPath": "C:\\Foo.sln" }
}Error codes (switch on code to handle each):
SymbolNotFound— type / method / property could not be resolved.SolutionNotTrusted—get_diagnosticsorget_code_fixesrequested analyzers but the solution hasn't been authorized viatrust_solution.AmbiguousMatch—set_active_solution/unload_solutionmatched multiple solutions;details.matcheslists them.FileNotFound— file path or baseline doesn't exist (or isn't in any loaded project).ProjectNotFound— solution name didn't match any loaded solution.InvalidArgument— caller-supplied input was malformed, unsupported, or out of range.Internal— unexpected error not modeled above;messagecarries the underlying exception text.
Cancellation: the MCP framework's native cancellation is honored. Cancelling a tools/call request mid-flight terminates the operation; long-running tools (get_diagnostics with analyzers, get_code_actions, apply_code_action, get_code_fixes) check the token at hot-loop boundaries.
External Assemblies
Metadata-origin symbols (from NuGet packages and referenced assemblies) are first-class citizens:
Tier 1 — Navigation (
find_references,find_callers,find_implementations): Accepts closed-source type and member names. Resolves them from assembly metadata and reports all source-level usage sites.Tier 2 — Inspection (
inspect_external_assembly): Browse namespaces, types, members, and XML doc comments from any referenced assembly without decompiling.Tier 3 — IL (
peek_il): Decompile a specific method to annotated ilasm-style IL using ICSharpCode.Decompiler — useful for understanding the internals of NuGet libraries.
Location-returning results include an Origin field (source or metadata) and an IsGenerated flag to distinguish hand-written code from closed-source or generated output.
Runtime configuration
ROSLYN_CODELENS_OPEN_PROJECT_TIMEOUT_SECONDS— per-project MSBuild load timeout (default300). When a project exceeds this duration during workspace open, it's recorded as aSkippedProjectsentry withkind: "Timeout"and the rest of the solution still loads. Useful when a legacy or malformed project wedges theBuildHost-net472subprocess.
Security: Trust Model
get_diagnostics and get_code_fixes can load Roslyn analyzers — DLLs that execute in-process. To prevent untrusted analyzers from running automatically, this server uses a VS/Rider-style trust model:
Solutions passed on the CLI at startup are auto-trusted for the current session.
Other solutions must be explicitly trusted via the
trust_solutionMCP tool.Analyzer DLLs must come from the user's NuGet global packages folder, the dotnet SDK install dir, or the solution's own
bin/obj. Other paths are skipped.
Use the list_trusted_paths and revoke_trust tools to inspect and manage trust state. Persistent trust is stored at %APPDATA%\roslyn-codelens\trust.json.
See SECURITY.md for the full threat model.
Quick Start
npx (any MCP client)
{
"mcpServers": {
"roslyn-codelens": {
"type": "stdio",
"command": "npx",
"args": ["-y", "roslyn-codelens-mcp"]
}
}
}The npm package ships no server code — it is a launcher that installs the RoslynCodeLens.Mcp
.NET global tool at a matching version and execs it, so the .NET 10 or 11 SDK must be on PATH.
Subsequent starts skip the install entirely and work offline.
VS Code / Visual Studio (via dnx)
Add to your MCP settings (.vscode/mcp.json or VS settings):
{
"servers": {
"roslyn-codelens": {
"type": "stdio",
"command": "dnx",
"args": ["RoslynCodeLens.Mcp", "--yes"]
}
}
}Claude Code Plugin
claude install gh:MarcelRoozekrans/roslyn-codelens-mcpThe plugin needs only the .NET 10 or 11 SDK: it runs the server through dnx, pinned to the
plugin's version, so there is no global tool to install or keep up to date.
.NET Global Tool
dotnet tool install -g RoslynCodeLens.McpThen add to your MCP client config:
{
"mcpServers": {
"roslyn-codelens": {
"command": "roslyn-codelens-mcp",
"args": [],
"transport": "stdio"
}
}
}Docker
Runs without a .NET SDK on the host; the solution is bind-mounted at /workspace.
docker build -t roslyn-codelens-mcp .
docker run -i --rm -v "$PWD:/workspace" roslyn-codelens-mcpThe mounted solution must be restored for MSBuildWorkspace to resolve its
references, and tool output reports container paths rather than host paths — see
docs/site/docs/getting-started/docker.md.
Usage
The server automatically discovers .sln files by walking up from the current directory. You can also pass one or more solution paths directly:
# Single solution
roslyn-codelens-mcp /path/to/MySolution.sln
# Multiple solutions — switch between them with set_active_solution
roslyn-codelens-mcp /path/to/A.sln /path/to/B.slnWhen multiple solutions are loaded, use list_solutions to see what's available and set_active_solution("B") to switch context. The first path is active by default.
HTTP transport
By default the server speaks stdio. Pass --http to expose the same tools over
streamable HTTP instead — useful for
one long-lived server (warm Roslyn workspace, no per-client startup cost) shared by several
local MCP clients:
roslyn-codelens-mcp /path/to/MySolution.sln --http # http://127.0.0.1:3001
roslyn-codelens-mcp /path/to/MySolution.sln --http --port 8080{
"mcpServers": {
"roslyn-codelens": {
"type": "http",
"url": "http://127.0.0.1:3001"
}
}
}The HTTP endpoint binds to 127.0.0.1 only and is intended for single-user, local use: all
connected clients share the same solution state (set_active_solution affects everyone), and
there is no authentication. --host can widen the binding, but the server will warn — its tools
can read and modify source files, so only do this on networks you fully trust.
Performance
All type lookups use pre-built reverse inheritance maps, member indexes, and attribute indexes for O(1) access. Benchmarked on an i9-12900HK with .NET 10.0.7:
Tool | Latency | Memory |
| 2.1 µs | 576 B |
| 2.5 µs | 720 B |
| 2.8 µs | 1.5 KB |
| 3.5 µs | 1.3 KB |
| 3.7 µs | 2.7 KB |
| 4.1 µs | 1.0 KB |
| 16 µs | 23 KB |
| 19 µs | 1.6 KB |
| 72 µs | 904 B |
| 78 µs | 24 KB |
| 115 µs | 14 KB |
| 159 µs | 35 KB |
| 265 µs | 3.5 KB |
| 478 µs | 16 KB |
| 564 µs | 259 KB |
| 705 µs | 19 KB |
| 781 µs | 25 KB |
| 792 µs | 54 KB |
| 797 µs | 101 KB |
| 822 µs | 99 KB |
| 849 µs | 48 KB |
| 885 µs | 247 KB |
| 1.1 ms | 104 KB |
| 1.1 ms | 34 KB |
| 3.5 ms | 286 KB |
| 3.8 ms | 224 KB |
| 3.9 ms | 557 KB |
| 5.8 ms | 333 KB |
| 7.0 ms | 335 KB |
| 8.4 ms | 396 KB |
| 10 ms | 337 KB |
| 12 ms | 399 KB |
| 15 ms | 788 KB |
| 23 ms | 1.0 MB |
| 28 ms | 1013 KB |
| 33 ms | 1.3 MB |
Solution loading (one-time) | ~4.1 s | 16 MB |
Hot Reload
The server watches .cs, .csproj, .props, and .targets files for changes. When a change is detected, affected projects are lazily re-compiled on the next tool query — only stale projects and their downstream dependents are re-compiled, not the full solution.
Location-returning tools include an IsGenerated flag to distinguish source-generator output from hand-written code.
Requirements
.NET 10 or 11 SDK
A .NET solution with compilable projects
Project compatibility
The server analyses every project that MSBuildWorkspace can load under the .NET SDK runtime.
Supported: SDK-style projects (<Project Sdk="...">), any target framework — net48, net6.0, net8.0, net10.0, etc. .NET Framework targets work fine as long as the csproj uses the SDK-style format.
Skipped (with a warning, not a crash): legacy non-SDK-style projects (<Project ToolsVersion="..." xmlns="http://schemas.microsoft.com/developer/msbuild/2003">, typically .NET Framework projects authored in older versions of Visual Studio). These rely on Microsoft.Common.props imports from the .NET Framework MSBuild that ships with Visual Studio, which is not available in the .NET SDK MSBuild runtime.
When a solution contains legacy projects, the server:
Loads every SDK-style project normally — all tools work for those.
Skips each legacy project and records it in
LoadedSolution.SkippedProjects.Surfaces the skipped list via
list_solutions(theSkippedProjectsarray on eachSolutionInfo) and in the return message ofload_solution. Each entry includes the project name, kind (Legacy), and reason.
To analyse a legacy project, convert it to SDK-style format (see Microsoft's migration guide) or open the solution from a Visual Studio Developer Command Prompt so the full Visual Studio MSBuild is on PATH.
Development
dotnet build
dotnet test
dotnet run --project benchmarks/RoslynCodeLens.Benchmarks -c ReleaseThird-party licenses
ICSharpCode.Decompiler — MIT license (v8+). Used for IL disassembly in the
peek_iltool.
Family
Roslyn CodeLens MCP is part of a small family of .NET projects for AI work:
AI.Sentinel: Security monitoring middleware for
IChatClient: prompt injection, hallucination and PII detection with an audit trail.Minos.NET: Typed, source-generated decision questions with calibrated answers.
Rag.NET: A modular retrieval-augmented generation pipeline on Microsoft.Extensions.AI.
MemoryLens MCP: On-demand .NET memory profiling with AI-actionable fixes over MCP.
Built on ZeroAlloc
Roslyn CodeLens MCP uses these ZeroAlloc libraries, which are source generators and analyzers with no reflection at runtime:
License
MIT
Available Tools
67 toolsanalyze_change_impactA
Analyze the blast radius of changing a symbol — shows every file, project, and call site affected. Combines find_references and find_callers into a single impact summary. Use before renaming, changing signatures, or removing a type/method.
Inputs: symbol (required).
analyze_control_flowA
Analyze control flow within a range of statements in a C# method. Returns reachability of start/end points, return statements, and exit points. Useful for detecting unreachable code and understanding branching.
Inputs: endLine (required), filePath (required), startLine (required).
analyze_data_flowB
Analyze data flow within a range of statements in a C# method. Returns variables declared, read, written, captured by lambdas, and flowing in/out of the region. Useful for understanding variable lifecycle before extracting code.
Inputs: endLine (required), filePath (required), startLine (required).
analyze_methodA
Get a comprehensive analysis of a method in one call: signature, location, all callers, and all outgoing calls (methods this method invokes). More efficient than calling find_callers separately.
Inputs: symbol (required).
apply_code_actionA
Apply a code action (refactoring or fix) by its title. Use get_code_actions first to discover available actions. Defaults to preview mode (returns diff without writing files). Set preview=false to apply changes to disk.
Inputs: line (required), column (required), filePath (required), actionTitle (required), +3 more.
change_signatureA
Add, remove, or reorder a method's parameters and update every call site (Roslyn's own change-signature engine). Cascades to overrides and interface implementations, rewrites named and optional arguments, and preserves an extension method's this parameter; the overrides and implementations it also rewrote are listed in CascadedTo. Operations apply in order: remove drops parameter; reorder takes order, a full permutation of the parameters surviving at that point; add appends name plus type and REQUIRES callSiteValue — the expression every existing call site will pass, since the tool never guesses call-site semantics — with an optional defaultValue that instead makes the parameter optional and leaves existing calls untouched. Rejected as unsafe: an added name that is not a valid C# identifier or collides with an existing parameter; a type that does not resolve, or resolves ambiguously (qualify it); moving or removing an extension method's this parameter (it must stay first); and any signature that would leave a surviving params array anywhere but last — add the parameter and reorder it before the params array, or remove that array. Defaults to preview mode (returns edits without writing files); set preview=false to apply. New compiler errors the change would introduce are reported as Conflicts, and apply mode refuses to write them unless force=true. Source-defined methods only; overloaded names must be disambiguated.
Inputs: method (required), operations (required), force, preview.
check_architectureA
Check user-supplied layering rules against the solution's real semantic type graph (resolved symbols, not using directives — so a fully qualified reference with no using is still caught, and an unused using is not reported). Rule kinds: forbid (a dependency from from to to is a violation) and allowOnly (a dependency from from to anything outside to is a violation). TWO SEMANTICS YOU MUST KNOW TO READ AN EMPTY RESULT CORRECTLY. (1) allowOnly evaluates ONLY solution-internal, non-generated targets: references to framework and NuGet namespaces such as System.Collections.Generic are ignored (otherwise every file would violate every allowOnly rule), and so are types declared entirely in generated code, which the caller cannot remove. To restrict a framework or generated namespace, write an explicit forbid — that path DOES evaluate metadata and generated targets. (2) Self-references are always allowed: a scope depending on itself is never a violation, under either kind. Results are grouped per violated rule plus sourceScope plus targetScope edge, each with a full referenceCount and the first maxSitesPerViolation sites. Sorted by rule order, then by descending reference count. Generated code is never reported as the SOURCE of a violation under either kind. Envelope adds a byRule / totalReferences / rulesEvaluated summary.
Inputs: rules (required), limit, scope, maxSitesPerViolation.
find_async_violationsA
Detect six classes of async/await misuse across all production projects: sync-over-async (.Result, .Wait*, GetAwaiter().GetResult()), async void outside event handlers, missing await in async methods, and fire-and-forget tasks. Returns a summary plus a per-violation list (severity error/warning, location, containing method, snippet). Skips test projects and generated code. Static analysis only — no fix suggestions.
Inputs: no named parameters.
find_attribute_usagesA
Find all types and members decorated with a specific attribute (e.g., Obsolete, Authorize, Serializable). Returns an envelope with items, totalCount, truncated, limit, and a byProject summary.
Inputs: attribute (required), limit.
find_breaking_changesA
Diff the current solution's public API surface against a baseline (JSON snapshot from a prior get_public_api_surface run, or a baseline .dll file). Reports five change kinds: Removed/KindChanged/AccessibilityNarrowed (Breaking) plus Added/AccessibilityWidened (NonBreaking). Returns a summary plus a per-change list (kind, severity, fully-qualified name, entity kind, project, file, line, details). Sort: Breaking before NonBreaking, then name ASC. Limitations: return type changes, sealed-ness changes, and nullable annotation changes are not detected (PublicApiEntry schema doesn't capture them).
Inputs: baselinePath (required).
find_callersA
Find every call site for a method. Returns an envelope with items, totalCount, truncated, limit, and a byProject summary.
Inputs: symbol (required), limit.
find_catch_blocksA
Find the catch clauses that handle an exception type across the solution, and say what each one does with it. Each item reports hasFilter (a when clause, so the handler may decline at runtime), rethrows (the body contains a bare throw;) and isEmpty (an empty handler body) — together these answer 'who is silently swallowing this exception?' in a single call. By default only clauses declaring exactly the requested type match; set includeBaseClauses to also surface handlers that catch a base type, including catch (Exception) and bare catch, since those bind the requested type too. caughtType is null for a bare catch. The exception type may live in source or in metadata. Returns an envelope with items, totalCount, truncated, limit and a byType / byProject summary, sorted by file, line, column.
Inputs: exceptionType (required), limit, includeBaseClauses.
find_circular_dependenciesA
Detect circular dependencies in the project reference graph or namespace dependency graph. Returns an envelope with items sorted by cycle length desc, totalCount, truncated, and limit (default 100).
Inputs: level, limit.
find_disposable_misuseA
Detect IDisposable / IAsyncDisposable instances at risk of leaking. Two patterns: local variables holding a disposable that aren't wrapped in using/await using/returned/assigned-to-field-or-out-parameter (warning), and bare-expression-statement discards of a disposable creator/factory (error). Returns a summary plus a per-violation list (severity error/warning, location, containing method, snippet). Skips test projects and generated code. Scope: methods only (not constructors/accessors/operators); ownership transfer via method/constructor argument is not detected. Static analysis only — no fix suggestions.
Inputs: no named parameters.
find_event_subscribersA
Find every += and -= site for an event symbol across the solution. Accepts source events (e.g. 'MyClass.Clicked') or metadata events (e.g. 'System.Diagnostics.Process.Exited'). Each result reports the source location, the resolved handler (method FQN, or a synthetic name like 'lambda at File.cs:N' for inline handlers), and the subscription kind (Subscribe for +=, Unsubscribe for -=). Use this for memory-leak audits (compare subscribe/unsubscribe pairs), UI event subscriber inspection, or when Grep over '+= EventName' would miss qualified or fully-typed subscription sites. Returns an envelope with items sorted by file path then line, totalCount, truncated, and limit (default 500).
Inputs: symbol (required), limit.
find_god_objectsA
Find types that combine high size with high coupling — 'god classes' that violate single-responsibility and become refactoring nightmares. Sharper signal than find_large_classes alone: a 1000-line internal helper used only by its own namespace is not flagged, but a 200-line class called from 15 different namespaces is. Two axes: size (lines/members/fields) and coupling (incoming/outgoing namespace counts). A type qualifies when it crosses ALL THREE size thresholds AND at least one coupling threshold — keeps DTOs (high field count only) and dispatchers (high member count only) off the list. Defaults: lines >= 300, members >= 15, fields >= 10, incoming-namespaces >= 5, outgoing-namespaces >= 5. Each threshold is independently configurable. BCL namespaces (System., Microsoft.) excluded from outgoing count. Test projects, generated code, interfaces, and nested types are skipped. Sort: total axes exceeded DESC, then line count DESC.
Inputs: project, minLines, minFields, minMembers, +2 more.
find_implementationsA
Find all classes/structs implementing an interface or extending a class. Returns an envelope with items, totalCount, truncated, and limit.
Inputs: symbol (required), limit.
find_large_classesA
Find classes and structs that exceed member count or line count thresholds. Returns an envelope with items sorted worst-first (highest size first), totalCount, truncated, and limit (default 100).
Inputs: limit, project, maxLines, maxMembers.
find_naming_violationsA
Check .NET naming convention compliance: PascalCase types/methods/properties, camelCase parameters, I-prefix interfaces, _ prefix private fields. Returns an envelope with items, totalCount, truncated, limit (default 500), and a byRule summary.
Inputs: limit, project.
find_obsolete_usageA
Find every call site referencing [Obsolete]-marked symbols in the solution, grouped by deprecation message and severity. Sharper than find_attribute_usages for migration-planning workflows: tells you 'we have 5 distinct deprecations pending; this one has 80 sites and is an error; that one has 3 sites and is a warning.' Includes both source-marked and metadata-marked obsoletes (third-party NuGet deprecations are surfaced too). Symbols with zero usages are omitted (no migration needed). Sort: errors first, then by usage count descending, then by symbol name. Test projects skipped. Project filter is case-insensitive.
Inputs: project, errorOnly.
find_referencesA
Find all references to a symbol (type, method, property, field, or event) across the solution, each tagged with a kind. Kinds: read, write, readwrite (compound assignment / ++ / ref), invocation, method_group, object_creation, cast, type_check (is / patterns / as-tests), typeof, base_type, type_constraint, type_argument, declaration, attribute, nameof, xml_doc, and usage (rare fallback). Pass kinds to return only some (e.g. ["write","readwrite"] for mutation sites). Envelope adds a byKind summary. Multiple references on one line are reported separately with a column.
Inputs: symbol (required), kinds, limit.
find_reflection_usageA
Detect dynamic/reflection-based usage like Type.GetType, Activator.CreateInstance, MethodInfo.Invoke. Returns an envelope with items, totalCount, truncated, limit (default 500), and a byKind summary.
Inputs: limit, symbol.
find_tests_for_symbolA
List test methods that exercise the given production symbol. Recognises xUnit, NUnit, and MSTest. Set transitive=true to follow helper methods up to maxDepth levels (default 3, max 5).
Inputs: symbol (required), maxDepth, transitive.
find_throw_sitesA
Find every place an exception type is thrown across the solution — throw new T(...), throw expr; and bare throw; rethrows (whose type comes from the enclosing catch). The exception type may live in source or in metadata, so System.ArgumentNullException works as well as your own MyApp.DomainException. Set includeDerived to also match subclasses of the requested type. Every throw in the file is reported, including throws inside lambdas and local functions, attributed to the member that contains them — use get_exception_flow instead when the question is which exceptions escape a specific method. Returns an envelope with items, totalCount, truncated, limit and a byType / byProject summary, sorted by file, line, column.
Inputs: exceptionType (required), limit, includeDerived.
find_uncovered_symbolsA
Report public methods and properties that no test method transitively reaches (within 3 helper hops). Output sorted by cyclomatic complexity descending, with a coverage summary including a riskHotspotCount (uncovered with complexity >= 5). Recognises xUnit, NUnit, MSTest. Reference-based static analysis — does not parse runtime coverage data.
Inputs: no named parameters.
find_unused_symbolsA
Find potentially unused types and members (dead code detection). Checks public symbols for references across the solution. Filters out test methods, MCP tools, source-generator output, MEF-composed services, and interop-laid-out fields. Returns an envelope with items, totalCount, truncated, limit (default 500), and a summary including byKind + filteredOut counts.
Inputs: limit, project, includeInternal.
generate_test_skeletonA
Emits a test-class skeleton (parseable C#) for a method or type. Pass a type FQN like 'MyApp.Services.OrderService' to get a full test class with one stub per public method, or a method FQN like 'MyApp.Services.OrderService.PlaceOrder' to get a single stub. Returns framework, suggested file path, class name, full file contents (as text), and TodoNotes for things to wire up (e.g. constructor dependencies). The tool does NOT write to disk — agent decides what to do with the text. Pairs naturally with find_uncovered_symbols / get_test_summary. Stubs include happy-path Fact, Theory + InlineData for primitive-param methods, and Assert.Throws assertions per distinct direct-throw exception type. Async (Task-returning) methods detected automatically. Properties, indexers, operators, and constructors are excluded from per-method enumeration. Framework auto-detected from solution test projects (tie → xUnit); override with framework='xunit' / 'nunit' / 'mstest'.
Inputs: symbol (required), framework.
get_call_graphA
Transitive caller and/or callee graph for a method symbol, depth-bounded with cycle detection. Output is an adjacency-list dict per direction (callees and/or callers), where each visited symbol maps to its outgoing edges. Direction: 'callees' (what this method transitively calls), 'callers' (who reaches this method), or 'both'. External (BCL/NuGet) callees appear as terminal leaves with isExternal=true. Declared signature only on callee side — no virtual dispatch resolution; agent uses find_implementations separately if needed. Callers side resolves dispatch naturally via Roslyn SymbolFinder. Hard cap on total visited nodes (default 500) — sets truncated=true if hit; edges to truncated targets are still recorded against the source node. Use this instead of recursive find_callers / analyze_method calls when you need depth > 1.
Inputs: symbol (required), maxDepth, maxNodes, direction.
get_code_actionsA
List available code actions (refactorings and fixes) at a position in a C# file. Optionally specify endLine/endColumn to select a range for extract-method style refactorings. Returns action titles that can be passed to apply_code_action. Returns an envelope with items sorted by kind then title, totalCount, truncated, and limit (default 100).
Inputs: line (required), column (required), filePath (required), limit, +2 more.
get_code_fixesA
Get available code fixes for a specific diagnostic at a file location. Returns structured text edits that can be reviewed and applied. Returns an envelope with items sorted by title, totalCount, truncated, and limit (default 100).
Inputs: line (required), filePath (required), diagnosticId (required), limit.
get_complexity_metricsA
Calculate complexity for members (methods, constructors, properties, indexers, operators). Reports both 'complexity' (cyclomatic - the number of paths, starts at 1) and 'cognitive' (how hard the code is to follow, starts at 0 - a 0 is not a bug), plus 'maxNesting'. The 'metric' parameter selects which of the two the threshold filters on and the sort uses. Returns an envelope with items sorted worst-first, totalCount, truncated, limit (default 100), and a summary with max/avg/overThreshold plus maxCognitive.
Inputs: limit, metric, project, threshold.
get_diagnosticsA
List compiler errors and warnings across the solution, optionally including analyzer diagnostics. Analyzer diagnostics require the solution to be trusted (see 'trust_solution'). Returns an envelope with items, totalCount, truncated, limit, and a severity summary.
Inputs: limit, project, severity, includeAnalyzers.
get_di_registrationsA
Scan IServiceCollection extension methods for DI registrations of a type. Returns an envelope with items sorted by service name, totalCount, truncated, and limit (default 200).
Inputs: symbol (required), limit.
get_exception_flowA
Which exceptions can escape a method — the 'is calling this safe?' question. Walks the method's callees depth-first (cycle-safe, depth- and node-bounded) collecting every explicit throw, then propagates each one back up the call chain, testing the enclosing try/catch at the throw and at every call site on the way out. Each item reports escapes, the path of methods from the analysed method to the one that raises it, and — when it is stopped — caughtIn, caughtFile, caughtLine. A handler with a when filter sets hasFilter and the exception is still reported as escaping, because the filter may decline at runtime. origin is thrown for a real throw site in source, or documented for an exception XML doc tag on a metadata (BCL/NuGet) callee — set includeDocumented to false to drop the latter. Throws inside lambdas and local functions are excluded: they escape when that body runs, not at this method's boundary — use find_throw_sites for a plain textual scan of throws. Static analysis only: no reflection, no virtual-dispatch resolution, and no implicit runtime failures such as null dereferences. Hitting maxDepth or maxNodes sets truncated.
Inputs: method (required), maxDepth, maxNodes, includeDocumented.
get_extension_methodsA
Answer 'what extension members can I call on this type?' — every extension method and C# 14 extension property applicable to a receiver type, from solution source AND referenced metadata (so BCL LINQ such as Where, Select, Chunk is included). Applicability is decided by the compiler's own reduction, not by name matching: this IEnumerable<T> is reported for string (which is IEnumerable<char>) while this IEnumerable<string> is not. Each entry carries the reduced call-site signature (receiver dropped, generic inference applied, return type first: IEnumerable<int> Where<int>(Func<int, bool>), int Tripled), kind (method or property), declaring type, namespace, origin (source or metadata), source file/line for source members, XML doc summary, and isStatic. Read isStatic before writing the call: false means an instance call (value.Doubled()) and is the normal case even though every extension method is DECLARED static; true means a C# 14 static extension member, called on the type itself (int.Zero). Results are NOT filtered by using scope — the tool has no call-site position, so every applicable member is reported and its namespace is given for you to add the import. Pass a type name: simple (Widget), fully qualified (MyApp.Widget), a C# keyword (int, string), a constructed generic (List<int>), an array (string[]), a nullable (int?), or a tuple ((int, string)). Sort: source before metadata, then declaring type, then name.
Inputs: type (required), limit, nameFilter.
get_file_overviewA
Get a summary of a C# file: which types are defined in it and any compiler diagnostics. Useful for quickly understanding a file's contents without reading it. Also accepts .razor/.cshtml markup, resolving it to the C# document its source generator produced.
Inputs: filePath (required).
get_generated_codeB
Inspect generated source code from source generators. Returns an envelope with items sorted by project then file path, totalCount, truncated, and limit (default 200).
Inputs: file, limit, generator.
get_instantiation_optionsA
Answer 'how do I construct this type?' in one call — accessible constructors, static factory methods declared anywhere in the solution, and DI registrations. Constructors report every parameter's type and name, declared accessibility, whether the constructor is compiler-supplied (isImplicit — a struct or a class with no declared constructor still has a usable parameterless one), and whether it is obsolete. Factories are static members returning the type, including ones declared on a DIFFERENT type such as WidgetFactory.Create(), with Task<T>/ValueTask<T> unwrapped and flagged isAsync. Instance builder methods are excluded because the builder itself would need constructing. Pass fromProject to get accessible computed for that project, which honours InternalsVisibleTo — this is how you find out whether your test project can reach an internal constructor. Without it, accessible is null, meaning NOT COMPUTED — which is not the same as false, so do not read a null as 'you cannot call this'. requiredMembers lists members that must be set in an object initializer. diRegistrations shows where the type is registered in a container — a registered type is usually meant to be resolved rather than constructed by hand. For interfaces, abstract classes and static classes, instantiable is false and note explains why; use find_implementations to find concrete types.
Inputs: symbol (required), fromProject.
get_method_sourceA
Return the full declaration source (XML docs, attributes, signature, body — original formatting) of one or more members by name: methods (all overloads returned), constructors (request as Widget.Widget or fully qualified Ns.Widget.Widget; nested types need full qualification), properties, indexers (request as Type.this or Type.this[]), fields, events. Batch-friendly: pass many names in one call instead of reading whole files. Per-item statuses: ok, notFound, ambiguous (with candidates), metadata (use peek_il or inspect_external_assembly), unsupportedKind (whole types — use get_type_overview). Items keep request order.
Inputs: symbols (required), limit.
get_nuget_dependenciesC
List NuGet package references for projects in the solution
Inputs: project.
get_operatorsA
Return every user-defined operator and conversion operator on a type in one call — source AND metadata. Each entry includes the operator kind (such as +, ==, implicit, explicit, plus all comparison and bitwise operators), full signature, parameter names/types/modifiers, return type, accessibility, an IsCheckedVariant flag for .NET 7+ checked operators (op_CheckedAddition etc.), XML doc summary, and source location (empty for metadata). Includes compiler-synthesized record equality operators. Returns declared operators only — operators do not inherit in C#. Pass a type name, simple or fully qualified (e.g. 'Vector2', 'MyApp.Money', 'System.Decimal'). Sort: kind ordinal ASC, then parameter count ASC, then signature ordinal ASC.
Inputs: symbol (required).
get_overloadsA
Return every overload of a method (or constructor) in one call — source AND metadata. Each overload includes the full signature, parameter names/types/modifiers (ref/out/in/params/optional with defaults), return type, accessibility, modifiers (static/virtual/abstract/override/async/extension), generic type parameters, XML doc summary, and source location (empty for metadata). Pass 'Type.Method' for ordinary methods or 'Type.Type' for constructors. Operator overloads are excluded — use get_operators for those. Sort: parameter count ASC, then signature ordinal ASC.
Inputs: symbol (required).
get_project_dependenciesA
Return the project reference graph (direct and transitive dependencies)
Inputs: project (required).
get_project_healthA
Aggregate 7 health dimensions per project in one call: complexity hotspots, large classes, naming violations, unused symbols, reflection usage, async violations, and disposable misuse. Returns counts per dimension plus the top-N hotspots inline (default 5) so the caller can prioritise without follow-up calls. Use this when answering 'how is this project doing?' / 'where should I focus?' / 'what's the technical debt picture?'. Underlying defaults: complexity threshold 10, large-class limits 20 members / 500 lines, unused symbols excludes internals. Test projects are skipped. Project filter is case-insensitive. Sort: projects ASC by name; hotspots sorted by severity proxy per dimension (cyclomatic complexity desc, line count desc, severity enum desc for async/disposable).
Inputs: project, hotspotsPerDimension.
get_public_api_surfaceA
Enumerate every public and protected type and member declared in production projects of the active solution. Returns a deterministically-sorted (name ASC) flat list of API entries (kind, fully-qualified name, accessibility, project, file, line) plus per-kind/per-project/per-accessibility summary buckets. Skips test projects, generated code, compiler-generated members, internal symbols, and protected members on sealed types (unreachable). Inherited members are not repeated under derived types — only declared members appear.
Inputs: no named parameters.
get_source_generatorsA
List source generators and their output per project. Returns an envelope with items sorted by project then generator name, totalCount, truncated, and limit (default 100).
Inputs: limit, project.
get_symbol_contextB
One-shot context dump for a type: namespace, base class, interfaces, injected dependencies, public members
Inputs: symbol (required).
get_task_statusA
Get the current status of a background task by its taskId.
Inputs: taskId (required).
get_test_summaryA
Per-project inventory of test methods. Each test reports framework (xUnit/NUnit/MSTest), attribute kind ([Fact]/[Theory]/[Test]/[TestCase]/[TestMethod]/[DataTestMethod]), data-driven row count, location, and the production symbols it references. Complements find_tests_for_symbol (which goes test → production); this goes project → tests. Use to answer 'what does this test suite cover?' or to break down test counts by framework/attribute. Production projects, generated code, and BCL/framework calls are filtered out of the per-test referenced-symbols list. Project filter is case-insensitive. Sort: tests by (file, line); projects by name ASC.
Inputs: project.
get_type_hierarchyB
Walk up (base classes, interfaces) and down (derived types) from a type
Inputs: symbol (required).
get_type_overviewA
Get a comprehensive overview of a type in one call: full context (namespace, base class, interfaces, members, DI dependencies), type hierarchy (bases, interfaces, derived types), and diagnostics in the file. More efficient than calling get_symbol_context + get_type_hierarchy + get_diagnostics separately.
Inputs: typeName (required).
go_to_definitionA
Find the source file and line where a symbol is defined. Returns an envelope with items, totalCount, truncated, and limit.
Inputs: symbol (required), limit.
inspect_external_assemblyA
Inspect a referenced closed-source assembly. mode='summary' returns namespaces + type counts; mode='namespace' returns public types and members for the given namespace.
Inputs: assemblyName (required), mode, namespaceFilter.
list_running_tasksA
List background tasks that are running or completed within the last 5 minutes.
Inputs: limit.
list_solutionsA
List all solutions loaded by this server, showing which one is currently active. Each entry includes any projects that were skipped during load (e.g. legacy non-SDK-style projects), with the kind and reason for each skip. Returns an envelope with items sorted by solution path, totalCount, truncated, and limit (default 50).
Inputs: limit.
list_trusted_pathsA
Return the current trust state: session-scoped paths, persistent paths, trusted roots, and analyzer policy.
Inputs: no named parameters.
load_solutionA
Load a .sln/.slnx solution at runtime and make it the active solution. Both include and rootProjects match against the project FILE NAME without extension (the .csproj/.vbproj base name), NOT the assembly name. Pass include (case-insensitive glob array, supporting only * and ? wildcards — character classes like [...] are NOT supported) or rootProjects (EXACT, case-sensitive file names) to load only a subset; the loader walks ProjectReference transitively from those seeds to keep the workspace semantically complete. A filter that matches NO project is an ERROR (the call fails) — it does NOT silently fall back to a full load; if unsure of exact names, do a no-filter load first and call list_solutions to discover them. If the same path is already loaded, providing a new filter disposes the previous workspace (replace semantics). If the solution is already loaded with no filter, it simply activates it (~instant). New solutions take ~3 seconds to load and compile. For very large solutions (hundreds of projects) that take minutes to open, pass background: true to return a taskId immediately instead of blocking; poll it with get_task_status until it succeeds (its result carries the loaded/skipped counts). The new solution only becomes active once the background load finishes, so other tools keep working against the current solution meanwhile.
Inputs: path (required), include, background, rootProjects.
peek_ilA
Return ilasm-style IL for a single method in a referenced closed-source assembly. Input must be a fully-qualified method name with parameter types.
Inputs: methodSymbol (required).
rebuild_solutionA
Force a full reload of the analyzed solution — re-opens the .sln, recompiles all projects, and rebuilds all indexes. Use after changing Directory.Build.props, adding/removing NuGet packages, or when diagnostics seem stale.
Inputs: no named parameters.
rename_symbolA
Safely rename a type or member across the entire solution (Roslyn Renamer). Cascades to references, constructors, overrides, nameof, and XML doc crefs. Defaults to preview mode (returns edits without writing files); set preview=false to apply. New compiler errors the rename would introduce are reported as Conflicts, and apply mode refuses to write them unless force=true. Locals/parameters and file renames are not supported.
Inputs: symbol (required), newName (required), force, preview, +3 more.
resolve_stack_traceA
Map a pasted .NET stack trace to file/line/symbol against the loaded solution, undoing compiler name mangling: async/iterator state machines (<M>d__N.MoveNext), lambdas (<>c / <>c__DisplayClass), local functions (g__Name|), generic arity. Handles Exception.ToString() output, log-prefixed lines, inner-exception chains, and Ben.Demystifier-style traces. Frames without 'in file:line' get the declaration site; frames with it keep the exact location. External frames resolve with origin=metadata. Items are in original trace order.
Inputs: stackTrace (required), limit.
revoke_trustA
Remove a previously trusted solution path or trusted root. Removes both session and persistent entries.
Inputs: path (required).
search_symbolsA
Search for types, methods, properties, and fields by name (case-insensitive substring match). Returns an envelope with items sorted by match quality (exact → prefix → substring), totalCount, truncated, limit (default 200), and a byKind summary.
Inputs: query (required), limit.
set_active_solutionA
Switch the active solution. All subsequent tool calls will operate on the selected solution. Use a partial, case-insensitive name (e.g. 'MyProject' matches 'C:/code/MyProject/MyProject.sln'). Returns the full path of the newly active solution.
Inputs: name (required).
start_background_taskA
Queue a long-running tool to run in the background. Returns a taskId; poll with get_task_status. Allowed tools: rebuild_solution.
Inputs: toolName (required).
trust_solutionA
Mark a solution path (or directory root) as trusted for analyzer execution. Required before get_diagnostics will load Roslyn analyzer DLLs from the solution. Always confirm with the user before calling this tool — analyzer DLLs run as in-process code.
Inputs: path (required), scope.
unload_solutionA
Unload a previously loaded solution to free memory. Use a partial, case-insensitive name (e.g. 'DcpCore' matches the full path). If the unloaded solution was active, another loaded solution becomes active. Use this when you're done analyzing a codebase and want to reclaim memory.
Inputs: name (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 67 tools
Most tools are distinct in purpose, but there is some overlap among query tools (e.g., find_references vs find_callers vs analyze_change_impact) and overview tools (get_type_overview vs get_symbol_context). Descriptions clarify the differences, so confusion is unlikely but not impossible.
All tool names follow a consistent snake_case verb_noun pattern (find_references, get_diagnostics, rename_symbol, change_signature, etc.). The naming is predictable and uniform, making the API easy to navigate.
With 67 tools, the server is extremely heavy. Although it covers a broad domain (analysis, refactoring, testing, dependencies), many tools are highly specific and could be consolidated (e.g., multiple find_* analyzers). This exceeds any reasonable threshold for typical usage.
The tool set provides comprehensive coverage of the code analysis domain: symbol lookup, references, diagnostics, code fixes, refactoring, test generation, architecture checks, dependency graphs, and more. No obvious gaps exist for the stated purpose of deep Roslyn-based analysis.
Maintenance
Related MCP Connectors
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
Augments MCP Server - A comprehensive framework documentation provider for Claude Code
Lean 4 MCP server: compile, prove theorems, and formalize math with Mathlib.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Related MCP Servers
- AlicenseAqualityBmaintenanceA Model Context Protocol (MCP) server providing 62 AI-optimized tools for .NET/C# semantic code analysis, navigation, refactoring, and code generation using Microsoft Roslyn. Built for AI coding agents - provides compiler-accurate code understanding that AI cannot infer from reading source files alone.6242MIT
- AlicenseAqualityBmaintenanceCode intelligence MCP server for Claude Code providing multi-project code graph, semantic search, session history, knowledge base, and web search.154MIT
- AlicenseNot gradedqualityBmaintenanceLocal-first MCP server for semantic C# analysis, navigation, validation, and refactoring using Roslyn on real .NET workspaces.2MIT
- AlicenseNot gradedqualityBmaintenanceA local .NET MCP server for coding agents, providing persistent semantic indexing, typed-graph DI wiring resolution, reduced context, and compiler-backed verification for .NET projects.37Apache 2.0