VisualMCP gives a coding agent the IDE's own tools over MCP: Roslyn's semantic model, the real MSBuild project graph, a debugger, a profiler and a decompiler, in one local process. It exists for a plain reason: reading and changing C# through grep and file reads spends tokens on guesses, while ReSharper, CodeMaid and Visual Studio answer the same questions in two clicks. This server puts those answers behind a tool call.
429 tools. Of the codes it fixes automatically: 97 of the 126 Visual Studio code-style ids (plus 41 for Visual Basic), 8 compiler diagnostics, 19 ReSharper inspections (16 with a code fix), ~800 analyzer inspection ids from five packs (each with its own fix where the analyzer ships one), 54 context actions and 60+ refactorings. Every write is a Roslyn operation, compiler-gated, recorded in the solution's edit history and revertible.
git clone https://github.com/matteofabbri/VisualMCP.git C:\REPOSITORY\VisualMCP
powershell -ExecutionPolicy Bypass -File C:\REPOSITORY\VisualMCP\scripts\install.ps1 -Scope all# Linux / macOS
git clone https://github.com/matteofabbri/VisualMCP.git ~/REPOSITORY/VisualMCP
~/REPOSITORY/VisualMCP/scripts/install.sh --scope allRestart your client, open any folder with a .sln, and say:
Audit this solution and tell me where to start.
One installer run installs the server and the visualmcp skill (plus the routing hook and the
AGENTS.md block). The skill is the product's front door, the way REA ships: it carries the routing
rules and the connection ladder, so on a machine where only the skill is present the agent connects
the MCP server itself — run the installer, restart, use the tools. A marketplace plugin
(.claude-plugin/plugin.json) bundles the same skill with the server registration in one move.
solution_audit reads the solution once and answers with the compiler's own diagnostics, the methods
ranked by cyclomatic and cognitive complexity, the project graph and the first move to make. Then the
work continues without a grep or a file read from you:
fix_complexitylowers the worst methods — a nested block extracted into a private method, a tangled boolean named, a tailifflattened into a guard clause — re-measuring after each step and rolling back anything that would not compile.reduce_complexitydoes the same for one method.simplify_codeapplies the Visual Studio code-style fixes below to a document, a project or the whole solution in one call;simplify_vb_codedoes the same for Visual Basic.fix_diagnosticsrewrites the mechanical compiler errors;apply_code_fixruns the analyzer's own fix for any inspection finding;context_actionapplies the ReSharper context actions.- 60+ refactorings — rename, extract method/class/interface/superclass, change signature, move type, inline — update every call site and are refused the moment they would add a compiler error.
The answer to "what is the most complex code here, and can you fix it" is one call, not a session of grep and reading. One call on our own codebase (a snapshot):
Solution: VisualMCP.sln — 6 project(s), 1,099 file(s), 229,639 line(s)
Compiler: 0 error(s), 18 warning(s)
3x CS8602 warning at StyleRewriteService.cs:492
3x CS8604 warning at VbStyleRewrites.Parameters.cs:59
2x CS8625 warning at VbStyleTests.cs:1022
2x CS8603 warning at UseBaseTypeService.cs:52
2x CS8601 warning at VbRefactoringTail.Moves.cs:147
Most complex methods (cyclomatic complexity, method length):
89 complexity 323 lines AnalyzeText(2 args) (YamlAnalyzer.cs:68)
83 complexity 342 lines Scan(2 args) (JavaScriptSymbols.cs:112)
64 complexity 294 lines AzureAsync(13 args) (RemoteHostService.cs:369)
63 complexity 272 lines MoveInstanceMethod(7 args) (MoveInstanceMethodService.cs:34)
63 complexity 265 lines MoveTypeToNestedScope(6 args) (MoveTypeToNestedScopeService.cs:36)
Project graph:
Snitch → (leaf)
Snitch.Metacode → Snitch
Snitch.Profiling → Snitch, Snitch.Profiling.Probe
Snitch.Profiling.Probe → (leaf)
VisualMCP → Snitch, Snitch.Metacode, Snitch.Profiling, Snitch.Profiling.Probe
VisualMCP.Tests → Snitch, Snitch.Metacode, Snitch.Profiling, Snitch.Profiling.Probe, VisualMCP
Suggested first moves:
1. Extract from 'AnalyzeText(2 args)' (complexity 89) — extract_method on its worst block.
The same audit ranks every method (complexity_report), names the decision points that own each score,
and git_churn_hotspots joins git history with complexity to say which file a refactoring pays for
first.
Every running server also hosts a web view of itself and of the solution store it writes, at
http://127.0.0.1:4677 — inside the MCP process, so there is nothing extra to launch. The store pages
are read-only GETs over SQLite and the live process. The board page is the one that edits: cards
are dragged between columns, and a card's panel changes its fields, comments it or deletes it, through
the same board service the board_* tools call — and only from a same-origin JSON POST the page itself
sends. A port that cannot be bound is a warning in the log rather than a failure of the MCP session.
| Page | What you see |
|---|---|
/ |
process facts (pid, uptime, working set, managed heap, runtime, transport), the loaded solutions, the store's counts, the latest tool calls and edits |
/board |
the project's board: five columns, a card dragged to move it, and a detail panel to edit, comment on, move or delete it |
/tables · /t/{table} |
every table the store contains, discovered from sqlite_master: filter across every non-blob column, sort, page, and export CSV or JSON |
/schema |
the columns of every table as SQLite reports them |
/tools |
the live tool catalogue with every argument, its type and whether it is required |
/log |
the tail of debug.log, newest first, refreshed every 2.5 s, filtered by text or by kind |
A column fixed on the left of every page lists the most recent tool calls — each a link to that tool's
rows in the command log — with the process facts at its foot. The same facts answer as JSON at
/api/health, /api/overview, /api/tables, /api/tables/{table} and /api/board.
VISUALMCP_DASHBOARD=off turns it off, VISUALMCP_DASHBOARD_PORT changes the first port it tries
(4677, then a port kept by an instance that is no longer running, then an OS-assigned one), and
VISUALMCP_DASHBOARD_HOST changes the interface — loopback is the default because the dashboard has no
authentication. The full reference —
every route and query parameter, the store's tables one by one, the JSON answers, the response headers
and the limits — is the web interface reference.
Every id below is a rewrite with a compiler gate: the file is left untouched if the result would add an
error. simplify_code rules=all runs all of them; one id, a list or a family works too.
| Ids | What it rewrites |
|---|---|
| IDE0001, IDE0002, IDE0003 | simplify a name, a member access, or remove this. |
| IDE0004, IDE0049 | remove a redundant cast; use the C# keyword for a framework type |
| IDE0007, IDE0008 | var / the explicitly written type |
| IDE0010, IDE0072 | complete a switch statement / expression over an enum |
| IDE0011 | add braces to an embedded statement |
| IDE0016 | a null check + throw → a throw expression |
| IDE0017 | an object initializer |
| IDE0018 | inline the out variable |
| IDE0019, IDE0020, IDE0038 | as + null check, is + cast, is without a variable → pattern |
| IDE0021–IDE0027, IDE0053, IDE0061 | expression body: constructor, method, conversion operator, operator, property, indexer, accessor, lambda, local function |
| IDE0028, IDE0300, IDE0301, IDE0302 | collection expressions: [], array, empty, stackalloc |
| IDE0029, IDE0030, IDE0031, IDE0074 | ??, ??=, ?. |
| IDE0033 | an explicitly provided tuple element name |
| IDE0034 | default(T) → default |
| IDE0035 | unreachable code |
| IDE0036 | modifier order |
| IDE0037 | an inferred member name |
| IDE0039 | a lambda → a local function |
| IDE0040 | the accessibility modifier |
| IDE0041 | x == null → x is null |
| IDE0042 | a deconstructing declaration |
| IDE0044 | readonly on a field |
| IDE0045, IDE0046 | a conditional expression for an assignment / a return |
| IDE0047, IDE0048 | redundant parentheses / parentheses for clarity |
| IDE0051, IDE0052 | an unused private member / an unread private field |
| IDE0054, IDE0056, IDE0057 | compound assignment, index operator, range operator |
| IDE0055 | formatting, as the project's .editorconfig asks |
| IDE0058, IDE0059 | an unused expression value / a store overwritten before it is read |
| IDE0060 | an unused parameter and its argument at every call site |
| IDE0062, IDE0320 | a static local function / a static lambda |
| IDE0063 | a using block → a using declaration |
| IDE0066 | a switch statement → a switch expression |
| IDE0070, IDE0071 | HashCode.Combine; a simplified interpolation |
| IDE0073 | the file header from file_header_template |
| IDE0075, IDE0100 | x ? true : false → x; x == true → x |
| IDE0079 | an unnecessary suppression |
| IDE0080 | an unnecessary null-forgiving ! |
| IDE0082, IDE0280, IDE0340 | typeof(X).Name and ArgumentNullException("x") → nameof(...); nameof(List<>) |
| IDE0083 | !(x is T) → x is not T |
| IDE0090 | new Foo() → new() |
| IDE0120, IDE0121 | Where(p).Any() → Any(p); Where(o => o is T).Cast<T>() → OfType<T>() |
| IDE0150 | x is object → x != null |
| IDE0160, IDE0161 | block-scoped / file-scoped namespace |
| IDE0170, IDE0260 | an extended property pattern; (o as T)?.M == v → o is T { M: v } |
| IDE0180 | a tuple swap |
| IDE0200, IDE0220, IDE0230 | an unnecessary lambda → method group; an explicit cast in foreach; a UTF-8 string literal |
| IDE0240, IDE0241 | a redundant / unnecessary #nullable directive |
| IDE0250, IDE0251 | readonly struct / readonly on a member |
| IDE0380 | an unnecessary unsafe |
| IDE0390, IDE0391 | make a method synchronous |
| IDE2000–IDE2006 | blank-line and layout rules |
Three more ids are answered by a dedicated tool instead of a rewrite: IDE0005 by optimize_usings,
IDE0032 by property_to_auto, IDE0290 by convert_to_primary_constructor. The remaining 26 ids of
the table are not rewrites at all — a refactoring, a project-layout decision, a naming rule, a compiler
diagnostic or a construct VB defines instead — and each is named with its reason in
the coverage page.
- 19 inspections implemented natively under ReSharper's ids (the opt-in
riderpack ininspect_code):ConditionIsAlwaysTrueOrFalse,ConvertToCompoundAssignment,ConvertToConstant.Local,EmptyConstructor,LoopVariableIsNeverChangedInsideLoop,MemberCanBeMadeStatic.Global,MergeIntoPattern,MethodOverloadWithOptionalParameter,RedundantArgument,RedundantBaseConstructorCall,RedundantCheckBeforeAssignment,RedundantIfElseBlock,RedundantLambdaSignatureParentheses,RedundantPatternParentheses,RedundantStringInterpolation,ReplaceSequenceEqualWithConstantPattern,ReplaceWithStringIsNullOrEmpty,StringLiteralAsInterpolationArgument,UseNameofExpression. 16 of them ship a code fix forapply_code_fix. - 54 context actions applied by
context_action: type import; eight argument guards (null, all parameters, string not null/empty, collection, variable, dictionary key, enum value, index range); four wrap actions (try/catch, try/finally, if, using) plus#region; the statement and declaration shapes (braces, foreach↔for, if→switch, split/join/merge checks, remove argument name,var/explicit type, split declaration, invert loop, extension block in both directions); the string conversions (raw, verbatim, regular, concatenation↔interpolation, split/join literals,''↔string.Empty); digit separators; nullable migration;ConfigureAwait(false);StringBuilder; pattern merging; LINQ in both directions; static member import/qualify/unqualify; a file header; a property over a backing field; block↔expression body. Visual Basic implements the 33 ids that have a VB spelling. - ~800 inspection ids from five analyzer packs — Roslynator (RCS), the .NET analyzers (CA),
AsyncFixer (ASYNC), Meziantou (MA) and StyleCop (SA) — reported by
inspect_code, fixed byapply_code_fixwhere the analyzer ships aCodeFixProvider, withinspection_baselineto show only what a change introduced.
IDE0001–IDE0004, IDE0009, IDE0010, IDE0017, IDE0029–IDE0033, IDE0035, IDE0036,
IDE0040, IDE0041, IDE0044–IDE0049, IDE0051, IDE0052, IDE0054, IDE0059, IDE0060,
IDE0070, IDE0071, IDE0073, IDE0075, IDE0081, IDE0082, IDE0084, IDE0100, IDE0120,
IDE0121, IDE0140, IDE0280, IDE2000, IDE2003.
The declaration-shape refactorings (apply_rename, change_signature, extract_method,
extract_interface, move_type, property_to_auto, inline_*, introduce_* and the rest) also run on
a .vb document, each under the same compiler gate.
The mechanical CS diagnostics no analyzer ships a fix for:
| Ids | What it does |
|---|---|
| CS0168, CS0219 | removes a local nothing reads — or keeps the side effect as a discard |
| CS0169 | removes a private field nothing uses |
| CS0067 | removes an event nothing raises |
| CS0105 | removes the duplicated using |
| CS0108, CS0114 | marks a hidden member new |
| CS0109 | removes a new that hides nothing |
429 tools, grouped by what you are trying to do. Every name is a tool; docs/tools.md gives the
one-line description of each, and docs/reference/tool-arguments.md its arguments. Scanners: 28 Razor
rules, 15 XAML, 18 JS/TS, 16 HTML + 10 CSS, 15 YAML, 12 SQL, 10 F#, 23 Kubernetes manifest checks.
- Solution and projects —
list_solutions,load_solution,check_solution,get_project_info,add_projects_to_solution,remove_projects_from_solution. - Files and text —
read_file,read_files,read_tree,list_directory,move_path,search_text,search_code,text_index,download_file. - Navigation and search —
find_symbol,find_file,read_symbol,find_references,find_callers,call_hierarchy,find_implementations,find_derived_types,get_symbol_info,get_type_members,solution_map,capability_report,find_endpoints,find_todos,analyze_stack_trace,structural_search(C# and VB). - Documentation —
get_xml_docs,find_undocumented_public_api,read_project_docs. - Analysis —
get_diagnostics,fix_diagnostics,run_code_analysis,solution_audit,inspect_code,apply_code_fix,inspection_baseline,configure_inspection,configure_formatting,suppress_finding,custom_inspections,resharper_inspection_map,read_dot_settings,find_spelling_issues,naming_rules,background_analysis,analysis_findings,complexity_report,get_complexity_hotspots,get_metrics,analyze_complexity,find_dead_code,find_unused_symbols,framework_entry_points,find_reflection_usage,list_generated_sources,find_external_usages,verify_change,find_breaking_changes,get_quality_trend,find_duplicate_code,analyze_test_quality,find_code_smells,find_missing_validation,analyze_nullability,find_security_issues,trace_data_flow,find_throw_sites,find_async_anti_patterns,find_performance_anti_patterns,find_regex_issues,analyze_dependencies,check_layer_violations,export_dependency_graph,call_graph,sequence_diagram,control_flow_graph,track_value,localization_report,analyze_circular_namespace_dependencies,analyze_dependency_injection,analyze_namespace_coupling,get_cohesion_metrics,git_churn_hotspots,plan_feature_change,list_analysis_tools. - Refactoring —
apply_rename,preview_rename,rename_namespace,rename_tuple_component,move_type,move_type_to_outer_scope,move_type_to_nested_scope,move_to_folder,move_to_namespace,move_static_members,move_instance_method,extract_method,extract_method_candidates,extract_class,extract_interface,extract_superclass,inline_class,inline_symbol,inline_parameter,inline_field,introduce_variable,introduce_field,introduce_parameter,introduce_part_of_string,change_signature,transform_parameters,change_type,change_nullability,use_base_type,add_params,remove_params,convert_to_primary_constructor,convert_to_record,convert_type_kind,convert_anonymous_to_type,constructor_to_factory,copy_type,encapsulate_field,property_to_auto,property_to_function,function_to_property,function_to_indexer,indexer_to_function,pull_members_up,push_members_down,make_static,make_non_static,generify,static_to_extension,extension_to_static,type_to_partial,extract_members_to_partial,global_usings,implicit_usings,convert_to_non_global_using,optimize_usings,reorder_members,remove_regions,safe_delete,safe_delete_file,safe_delete_folder,invert_if,invert_boolean,context_action,templates,migration_campaign. - Generation —
implement_members,implement_inpc,create_from_usage,generate_docs,generate_members,generate_builder,generate_dto_from_json,generate_dto_from_xml,generate_comparer. - Code style —
simplify_code,simplify_vb_code,code_cleanup,layout_code,format_code,fix_complexity,reduce_complexity. - Build, run and publish —
build_project,analyze_binlog,project_properties,run_project,run_config,launch_settings,run_command,dotnet_publish,publish_profile,add_project_reference,remove_project_reference,extract_build_log_errors,get_environment_info,disk_usage,stop_server,project_template,installer_project,deploy_target. - Testing —
run_tests,get_test_coverage_map,run_test,rerun_failed,tests_covering_symbol,run_covering_tests,generate_tests,test_impact_analysis,run_affected_tests,list_tests,debug_test,continuous_testing,find_flaky_tests,run_mutation_tests,verify_change. - Debugging —
debug_status,debug_install,debug_launch,debug_attach,debug_breakpoints,debug_function_breakpoints,debug_data_breakpoints,debug_continue,debug_step,debug_pause,debug_exceptions,debug_threads,debug_stack,debug_variables,debug_evaluate,debug_output,debug_restart,debug_terminate,debug_sessions. - Benchmarks and profiling —
run_benchmarks,quick_benchmark, and the 28profile_*tools:profile_processes,profile_tools,profile_collect,profile_analyze,profile_root_cause,profile_async,profile_database,profile_events,profile_instrumentation,profile_counters,profile_stacks,profile_heap,profile_retention,profile_dump,profile_symbols,profile_monitor,profile_allocations,profile_calltree,profile_hotpaths,profile_hotlines,profile_io,profile_file_io,profile_compare,profile_diagnose,profile_slowdown,profile_memory_growth,profile_threadpool,profile_review_change. - NuGet, packages and modernization —
list_nuget_packages,check_nuget_updates,check_nuget_vulnerabilities,fix_nuget_vulnerabilities,locate_nuget_package,inspect_package,inspect_packages,decompile_package_type,search_nuget_packages,nuget_sources,add_nuget_package,remove_nuget_package,update_nuget_package,unify_nuget_version,nuget_pack,nuget_push,aspire,update_framework,update_solution,ef_migrations,package_facts. - Razor, XAML, SQL and the scanned languages —
razor_pages,analyze_razor_pages,find_razor_vulnerabilities,razor_edit;xaml_pages,analyze_xaml,xaml_bindings,xaml_tree,xaml_navigate,xaml_rename,xaml_extract_style,xaml_promote_resource,format_xaml;sql_files,analyze_sql;js_files,analyze_js,js_symbols;markup_files,analyze_markup;yaml_files,analyze_yaml;fsharp_files,analyze_fsharp,fsharp_symbols. - Decompilation, IL and metacode —
inspect_assembly,inspect_assemblies,find_assembly_api,decompile_type,decompile_types,decompile_assembly,assembly_workspace,disassemble,metacode_translate,metacode_compare,metacode_index,metacode_generate,translate_python_file,translate_cpp_file,decompile_to_metacode,analyze_native_binary,metacoding. - Git, GitHub and other hosts —
git_status,git_diff,git_log,git_stage,git_commit,git_amend,git_squash,commit_lint,git_branch,git_create_branch,git_merge,git_conflicts,git_rebase,git_cherry_pick,git_revert,git_reset,git_stash,git_patch,git_tag,git_remote,git_show,git_blame,git_sync,git_worktree,git_bisect,git_submodule,git_host,git_run;gh_repo,gh_pr,gh_issue,gh_release,gh_actions,gh_secret,gh_branch_protection,github,code_review. - Containers, clusters and Node —
docker_status,docker_ps,docker_inspect,docker_logs,docker_control,docker_rm,docker_run,docker_images,docker_pull,docker_image_rm,docker_networks,docker_volumes,docker_stats,docker_compose,docker_prune;k8s_status,k8s_context,k8s_get,k8s_describe,k8s_logs,k8s_kustomize,k8s_validate,k8s_port_forward,k8s_exec,k8s_apply,k8s_delete,k8s_rollout,k8s_helm;node_info,node_install,node_script,node_typecheck,node_lint,node_outdated,node_audit. - Planning, automation and protocols —
board_brief,board_audit,board_remember,board_recall,board_forget,board_add,board_update,board_move,board_comment,board_list,board_show,board_board,board_import,board_export,board_delete,create_task_checklist,update_task_checklist;run_plan,http_invoke,run_http_file,http_file,signal_r_connect,signal_r_subscribe,signal_r_events,signal_r_invoke,signal_r_logs,signal_r_list_sessions,signal_r_disconnect. - Maintenance, scaffolding and self-management —
command_log,edit_history,revert_edit,local_history,reference_index,host_system,fix_line_endings,list_licenses,add_license,add_contributing,add_ci_workflow,check_for_update,self_update.
A tool call is not one message. Every call re-sends the conversation to the model and appends its result, so a chain of five calls pays for the transcript five times. Two things move that number, and both are structural rather than tuning:
- One call instead of a chain.
read_symbolis whatgrep+Read+ "no, the other overload" used to be.search_codereturns every hit already resolved to the declaration that contains it.find_referencesanswers with real uses, so there is nothing to disambiguate with a second read.inspect_codeandsolution_auditreplace a page of greps with one report,profile_diagnoseone probe with a set of correlated ones, andrun_plana mechanical fan-out — onesimplify_codeper file, then a build — with a single call. - A narrower answer.
read_symbolsends one declaration, not the file around it.decompile_typecompacts ILSpy's C# — indentation, blank lines and comments dropped, the same tokens in about half the characters.profile_hotlinessends the lines that burn CPU, not the trace, andprofile_root_causesends the loop, not the sample dump.
The chains this removes are not hypothetical. Measured on our own sessions (a 2026-10-29 snapshot: 51
sessions of this project, 10,249 recorded tool calls), 244 round trips existed only because the
previous answer taught the model a name it then had to go and look up — over 4,176 VisualMCP calls in
736 turns (agent ergonomics). The dominant one is search_text →
read_file, 134 times: the match line was not the code, so the next call went and read it. Against
1,957 raw navigation calls stood 104 symbol-level ones. Those 244 are a floor, from sessions that
already know this codebase — a first visit to an unfamiliar solution pays more, because every
orientation call is a round trip.
| The detour | Now |
|---|---|
| grep the name, read the files it hit, re-read the one whose hit was a comment | find_references / find_callers — one call, real uses, every overload |
| open the file to see one method | read_symbol — the declaration, with its XML docs |
| grep for a string, then read around each hit | search_code — the declaration per hit, one call |
| twelve greps to answer "what does this support" | capability_report / solution_map — one call |
| collect counters, then a trace, then read both | profile_diagnose — one call, the findings correlated |
one simplify_code per file, then a build |
run_plan — one call for the whole fan-out |
Four invariants hold across all 429 tools:
- Semantic, not textual. Every write is a Roslyn operation on the real project, never a regex over files.
- Compiler-gated. An edit that adds a compiler error is refused. The whole run rolls back if the fixes together would break the build.
- Recorded and revertible. Every file the server writes lands in the solution's edit history with
its before-and-after hash;
revert_editundoes it, and the revert is recorded too. - Read-only where it says so. Analysis and profiling never modify anything; the mutating tools are marked ✎ and most default to a dry run.
One server serves one workspace: the folder the client opened is fixed for the life of the process,
and load_solution cannot leave it. Another repository is another server, with its own store and board.
The model, including what happens with two sessions on the same folder, is
The workspace, the store and multiple sessions.
Metacode is the canonical pseudocode model behind the analysis: it reads C#, Visual Basic, Razor pages, JavaScript/TypeScript, Rust and Java source, Python and C++ AST dumps, decompiled .NET assemblies and recovered native binaries — persisted per declaration, diffable, generatable back to C#. Two spellings of the same algorithm compare line-by-line across languages, so the same vocabulary describes a Ghidra recovery and a Razor page.
| grep and file reading | index-based code MCPs | VisualMCP | |
|---|---|---|---|
| Cost of an answer | 3+ calls, each re-sending the conversation | 1–2 calls, in an index's terms | one call, in the compiler's terms |
| Understands C# | finds the text of a symbol | indexes identifiers | compiles the solution — overloads, generics, dispatch |
| Renames safely | renames comments and strings too | misses cross-file uses | every real reference, compiler-gated |
| Fixes the build | shows you the log tail | reports findings | fixes the mechanical errors itself |
| Debugs and profiles | — | — | a real debugger and a real profiler |
| Edits you can trust | writes whatever the model says | same | gated, recorded, revertible |
What is compiled. C# and Visual Basic are read through Roslyn's semantic model, so overloads, generics, interface dispatch and references resolve the way the compiler resolves them. Visual Basic gets that model too; the only refactorings it refuses are the three constructs it cannot express (records, primary constructors, nullable reference types).
What is not compiled. XAML, Razor, SQL, JavaScript/TypeScript, HTML/CSS, YAML and F# are read as markup
or as patterns, not compiled. Razor and XAML have their own markup scanners; a XAML binding path is resolved
against the data type the markup names and comes back not-checked when no type can be named. SQL,
JavaScript/TypeScript, HTML/CSS, YAML and F# run numbered rule sets over source whose comments and literals
are masked first (analyze_sql, analyze_js, analyze_markup, analyze_yaml, analyze_fsharp).
JavaScript/TypeScript reports an import cycle as JS0018, and the CSS selector engine resolves the
structural :nth-child()/:nth-of-type() families against the page index. HTML and CSS are scanned,
never rendered. No scanner type-checks an expression, and a green run means no rule matched, not that
the code is correct.
What is lexical. JavaScript/TypeScript and F# also get a lexical symbol table (js_symbols,
fsharp_symbols): the declaration a name resolves to, and its references, with no type model behind it. A
member reached through an untyped object, a computed name or eval is not resolved. The project's own tsc
and eslint remain the authority on types and lint (node_typecheck, node_lint); F# is not a Roslyn
language, so the compiler's own FS#### diagnostics come back through build_project.
What is wrapped. Node, Docker and Kubernetes are not reimplemented: node_* runs the project's
npm/pnpm/yarn, k8s_* runs kubectl and helm, docker_* runs the engine, and a missing client is
reported rather than installed. The Kubernetes check this server performs itself is k8s_validate, an
offline manifest validator over the built-in kinds (K8S001–K8S023): it proves the manifest's shape, not that
a cluster will accept it.
What no result proves. Everything here is static analysis or process instrumentation. The compiler gate
proves compilation, never behaviour. A sampled stack is statistical, a decompiled body is a reconstruction,
a scanner reports shapes. verify_change measures behaviour by running your suite on both sides and diffing
the outcome test by test; code the suite does not cover comes back unverified, not safe. Nothing replaces
your test suite. Every boundary, per language and per area, is in the coverage page's cross-cutting
table and
requirements and guarantees.
Where it runs. On your machine, in one local process: no hosted service, no account, no daemon. Your code leaves the box only in the conversation your client already sends to its model provider, the same place every tool result goes. The exact statement is How it works.
| If you want to… | Read |
|---|---|
| install, verify, upgrade, uninstall | Getting started |
| understand the process, the store, the dashboard, privacy | How it works |
| browse the running server's store, tools and log in a browser | Web interface |
| look up a tool | Tool catalogue · Tool arguments |
| read and analyse code | Reading and analysing code |
| refactor safely, apply style fixes | Refactoring and style |
| work on Razor, metacode or decompilation | Razor, metacode and decompilation |
| build, test, manage NuGet, modernize | Build, test, packages and modernization |
| profile a live process | Profiling |
use run_plan, planning, Git, GitHub, Docker |
Workflow and integrations |
| configure ports, paths and environment variables | Configuration reference |
| know what it does not do | Cross-cutting boundaries and requirements/guarantees |
| see the ReSharper/CodeMaid coverage, row by row | Coverage |
| troubleshoot | Help and FAQ |
| contribute | CONTRIBUTING.md |
The engineering notes behind these pages are indexed in docs/README.md. Every folder has its own README: the engine, language layers, libraries, the solution, the MCP host, the test suite, scripts, hooks, client skills, docs and samples.
dotnet build VisualMCP.sln # engine + host + tests
dotnet test src/VisualMCP.Tests/VisualMCP.Tests.csproj # the suite: 1,578 test methods
powershell -ExecutionPolicy Bypass -File scripts\reload.ps1 # rebuild + republish the serverArchitecture rules and the one-type-per-file rule are in CONTRIBUTING.md. After adding or removing a tool, reconnect the MCP server so the client refreshes its tool list.
VisualMCP is licensed under the PolyForm Noncommercial License 1.0.0.
- ✅ Free for noncommercial use — individuals, hobby and personal projects, learning, research, education, and other noncommercial organizations.
- 💼 Commercial / company use requires a paid license. Any use by or for a company (or for commercial advantage or monetary compensation) needs a separate commercial license. Contact me@matteofabbri.org.
Source-available, not OSI "open source": read it, fork it, contribute to it — commercial use is
reserved. See LICENSE for the exact terms.
This summary is for convenience only and is not legal advice; the LICENSE file governs.