OpenSysML MCP server

Run an analysis case — once, over the rows of a sweep (`ranges`), or as a Monte Carlo sample (`runs`) — and record the runs into the model as AnalysisRecords declarations (the RecordRun RPC, the CLI's -record-run/-record-into, the REPL's %record). `run`, `sweep` or `sample` is the runs' own report; `package`, `definition` and `records` name what the model gained and `source` is the declarations generated; `documents` (and `content` for a single document) is the notation of the document the records merged into, or the records as a document of their own, and `modelHash` names the recorded model, cached for the next request. A recording that would error or drop a declaration leaves the model unchanged and is the `error`. The result is the RecordRunResponse as protojson writes it.

Find every place in the workspace that refers to the element at a position.

Rename the element declared or referenced at a position, everywhere in the workspace. Returns the edits per document; writes the files only with apply=true.

Render a document definition (doc def) to Markdown, its queries evaluated over the workspace and its diagrams embedded.

Render a named document of a model given by modelHash, paths or sources (the workspace group's render_document renders by name over the root) — a part def specializing DocumentQueries::Document — to Markdown, HTML or AsciiDoc (the RenderDocument RPC, the CLI's -render-document), byte for byte what the CLI writes. The text is the rendered document; the result is the RenderDocumentResponse as protojson writes it.

Render a declared view or a targeted pseudo-view of a model given by modelHash, paths or sources as diagram data (the RenderView RPC; the workspace group's render_view renders by name over the root): nodes flattened parents first, edges with their ports, table columns and rows, canvas, notes and notices. The result is the RenderViewResponse as protojson writes it; the text lists the nodes and edges.

Render the run a session recorded as a state timeline or a message sequence (%render-run), in a text, diagram or SVG form. Recording must be on before the run: repl_command `%trace on`.

Render a diagram or table of a document: a declared view or a pseudo-view, as Mermaid, Graphviz dot, PlantUML, D2, draw.io (diagrams.net XML), text, Markdown, CSV or TSV. The result also lists the nodes and edges drawn with their qualified names (for apply_model_edit) and their declaration ranges in LSP form (0-based).

Run one sysml prompt command (a % line) in a session and return what it printed. Prefer the typed tools, which return the same data structured: session_load/session_submit/session_eval/session_print/session_save/session_clear, session_run, debug_*, send, advance, features, instances, check/explain/solve/configure/optimize, sweep, runs, render_run. This tool reaches everything else the prompt can do — %instantiate, %invoke, %constraint, %requirement, %satisfy, %validate, %calc, %analysis, %record, %import, %run-query, %render, %viz, %render-document, %trace, %schedule, %seed, %engine, %jobs, %budget, %verbosity, %strict, %lint, %search, %views, %documents, %list, the %check-* settings and the repository commands. Discover the commands with `%help` (every command with its arguments) and the settings with the command alone (`%schedule`, `%engine`). A command that reports an error fails the call with its output.

Run an analysis case (the RunAnalysis RPC, the REPL's %analysis): its subject and inputs bound from the arguments and its own declarations, its body run, every declared output answered with the verdict of its objective and of each assertion in its body; a verification case also answers its own verdict. A trade study's evaluations of each alternative are in `evaluations`. Under an explore schedule the answer is the set of distinct `outcomes`. Bounded by the service's OPENSYSML_MAX_* budgets. The result is the RunAnalysisResponse as protojson writes it.

Run a named document query with parameter bindings and answer its typed rows (the RunDocumentQuery RPC, the REPL's %run-query). The query runs over the model and over the objects instantiate created for the same modelHash, which a binding may name. The result is the RunDocumentQueryResponse as protojson writes it; the text is the table.

Run an action, or a Simulation::MonteCarlo analysis case, a number of times (the RunRuns RPC, the CLI's -runs/-observe, the REPL's %runs): every run is an ordinary run in a context of its own, drawing its modeled randomness from a seed derived from `seed`. `rows` is the table, one row per run with the run number as its input and what it observed as its outputs; `distributions` summarises each observable over the completed runs (extremes, mean, deviation, percentiles, histogram, or the count of each distinct value); for a case `outputs` and `verdicts` are its conclusion over the sample and `unconcluded` why it has none. A run that failed is its row's error. The result is the RunRunsResponse as protojson writes it.

Run an analysis case or calc once per row of a parameter sweep (the RunSweep RPC, the CLI's -sweep): each row an ordinary run with the swept parameters bound to that row's values, stepped through the ranges' cartesian product or drawn with samples and seed. A failed row is a row with `error`, not a failed table. Bounded by the service's OPENSYSML_MAX_* budgets. The result is the RunSweepResponse as protojson writes it; the text is the table.

Run an action count times, each run's modeled randomness seeded on its own, and return the table of the observables with each one's distribution (%runs); or run a Simulation::MonteCarlo analysis case count times on fresh subjects and conclude it.

Apply the SysMLValidation constraints, and those of any rule packages named, reflectively to every element of a model (the SelfCheck RPC, the CLI's -self-check and -self-check-package): each element is handed to every constraint whose input its metaclass conforms to. `status` is holds, fails or unresolved; `findings` carry each violation, evaluation the runtime could not make, error and skipped rule constraint with the element's location and the line the CLI prints; the counts and `applications` say how much was checked. The result is the SelfCheckResponse as protojson writes it.

Send a signal to an object through the runtime's message bus (%send), for the state machine it exhibits or the action parked at a matching accept to take; by default to the object whose behavior is being debugged. The signal is refused when no behavior of the object accepts it now. It is dispatched by the next debug_step or advance.

Report the OpenSysML runtime's version and the named capabilities this build supports.

Reset a session, as %clear does: every declaration, object and debugging session goes; the session stays open and empty.

Close a REPL session, discarding its model, instances and any run in progress.

Evaluate an expression in a session, as %eval does: a literal, a declared feature or qualified name, an enumeration literal, a unit, or a compound expression over the session's declarations. Returns the value as data and as the prompt prints it.

List the open REPL sessions.

Load model files into a session, as %load does: files, directories or globs, resolved against the workspace root and refused outside it. Every file is accepted before the model is analyzed, so load order does not matter, and files beside the paths that declare a namespace they import load too. Returns what loaded and the diagnostics.

Open a named REPL session: an empty model that declarations, instances and runs accumulate into across calls. The default session opens itself on first use, so this is only needed for a second, independent session, or for one with a root: a directory under the workspace root whose model files load on demand, as %load would load them, when a submission imports or qualifies a root namespace that neither the session nor the library declares.

Print a session's model as SysML notation, or one named element with its body, as %print does. Comments are kept, and what is printed can be submitted back.

Run a behavior in a session to completion and report what it produced: an action (%action then %continue), a state machine (%state, then %advance when a duration is given), a calc (%calc) or an analysis case (%analysis). Objects the run creates stay in the session, and the run's executor stays inspectable with debug_current until the next run or debug_stop. Under %engine check the behavior is checked over every schedule instead.

Write a session's model to a file under the workspace root, as %save does: .sysml notation with comments preserved, or .ttl/.json RDF (experimental). A path outside the root is refused. Without apply nothing is written and the file's content, in the format the extension names, is returned as content.

Submit SysML declarations to a session, as typing them at the prompt does: the text joins the model, the whole model is re-analyzed, and what it declared and the diagnostics about it come back. Submitting a name again replaces its earlier declaration. For an expression use session_eval; for a % command use repl_command.

Describe the invocation enclosing a position: the callable's parameters and which one the position is at.

Ask an SMT solver for values satisfying an element's conditions (%solve, experimental), keeping the values the model already fixes; reports the conflict when the fixed values admit none.

Run a calc or analysis case once per row of the ranges given (%sweep), or over rows drawn from them (%samples), and return the table: each row's inputs, outputs, verdicts and timing. The verdict holds when every run completed and every objective was satisfied.

Describe one element of a parsed model by qualified name (the GetSymbol RPC): its kind, metadata, children, attributes with their declared values, static type facts, multiplicity and specializations. An unknown name answers with `error` set rather than failing. The result is the SymbolResponse as protojson writes it.

List the tools this server serves: each tool's name, group, the sysml-grpc RPC or `sysml` CLI flag it stands for, and a one-line summary. Pass `group` (lsp, runtime, session) to narrow the list. The same catalog generates the Tools section of the sysml-mcp manual page.

Replace the text of a document held open by open_document and re-analyze it. Nothing is written to disk. Returns the diagnostics of the new text.

Validate an object of a part as a whole (the ValidateInstance RPC, the REPL's %validate): every assertion about an object of symbolId and about the objects it holds — asserted constraints of their types, the requirements they carry, the satisfactions they are the subject of — each answered on the concrete object, with a `summary` verdict about the object as a whole. The result is the ValidateInstanceResponse as protojson writes it.

Ask whether a constraint holds (the VerifyConstraint RPC, the REPL's %constraint): against its declared values, or against an object of subjectSymbolId built for the call. The answer is a Verdict: `holds`, the violated `condition`, or an `error` when nothing was decided, with the engine and strength of evidence. The question holds or satisfiable puts it to a solver over the free variables and answers with a witness assignment. The result is the VerifyConstraintResponse as protojson writes it.

Ask whether a requirement is satisfied (the VerifyRequirement RPC, the REPL's %requirement): its require constraints evaluated against declared values or against an object of subjectSymbolId. Beside the Verdict the answer carries what every verification case verifying the requirement concluded (pass, fail, inconclusive, error). The result is the VerifyRequirementResponse as protojson writes it.

Evaluate the satisfy assertions a model states (the VerifySatisfaction RPC, the REPL's %satisfy): each against an object of its subject built for the call, answering one Verdict per assertion in declaration order. A model stating no assertion answers an empty list, not an error. The result is the VerifySatisfactionResponse as protojson writes it.

List the views a document declares and the pseudo-views (#tree, #interconnection, ...) render_view can draw of it.

Analyze a SysML v2 / KerML document, or the whole workspace, and list the errors, warnings and hints: syntax, unresolved names, type and constraint violations. Positions are 1-based lines and columns.

Describe the SysML v2 workspace the server has indexed: its root folder and the model documents found under it.

Search the workspace's declared elements by name substring.