Provides a deterministic, read-only lookup for TRIZ principles, matrices, and engineering parameters to prevent LLM hallucinations during problem-solving.
Also known as sv/triz-skill, triz-skill, triz-mcp
- Stars
- 0
- Tools
- 42
- Downloads, 30 days
- —
- Latest version
- 0.5.1
- Last commit
- Nov 1, 2026
- License
- MIT
What is TRIZ MCP?
TRIZ provides a deterministic, read-only lookup for TRIZ principles, matrices, and engineering parameters to prevent LLM hallucinations during problem-solving. It exposes 42 tools, such as triz_parameter, triz_principle, triz_matrix.
Summary generated from the project's README
About TRIZ MCP server
TRIZ provides a deterministic, read-only lookup for engineering principles, matrices, and parameters to prevent AI hallucinations during technical problem-solving. Instead of relying on memory, which can lead to incorrect principle numbers or matrix cells, this server uses a canonical JSON knowledge base to ensure every citation is accurate. It is designed for developers and engineers using AI agents to solve complex contradictions in products, services, or technical systems.
The server can be run locally via stdio using npx or pnpm, requiring a TRIZ_DATA_DIR environment variable if the data is stored outside the repository. For a public utility, a hosted version is available as a Cloudflare Worker over HTTP. The toolset includes specialized functions like triz_matrix for contradiction lookup, triz_parameter for engineering metrics, and triz_principle for inventive methods. It also supports advanced modeling tasks such as triz_build_model and triz_function_model to verify system behavior and identify harm loops.
What you can do with it
- 1Modeling and verifying system behaviorUsers can build typed function models to check for bottlenecks, leaks, or harm loops in a design.
- 2Evaluating design trade-offsAn engineer can rank multiple candidate designs against specific resource and cost metrics using Pareto analysis.
Written from the project's README. Every use case is checked against a quote from it.
How to install TRIZ MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall TRIZ MCP in Claude Code
$ claude mcp add triz-skill -- npx -y triz-mcpInstall TRIZ MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"triz-skill": {
"command": "npx",
"args": [
"-y",
"triz-mcp"
]
}
}
}Install TRIZ MCP in VS Code
.vscode/mcp.json
{
"servers": {
"triz-skill": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"triz-mcp"
]
}
}
}Install TRIZ MCP in VS Code CLI
$ code --add-mcp '{"name":"triz-skill","type":"stdio","command":"npx","args":["-y","triz-mcp"]}'Install TRIZ MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"triz-skill": {
"command": "npx",
"args": [
"-y",
"triz-mcp"
]
}
}
}Install TRIZ MCP in Codex
$ codex mcp add triz-skill -- npx -y triz-mcpInstall TRIZ MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.triz-skill] command = "npx" args = ["-y", "triz-mcp"]
Install TRIZ MCP in Gemini CLI
$ gemini mcp add -s user triz-skill npx -- -y triz-mcpInstall TRIZ MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"triz-skill": {
"command": "npx",
"args": [
"-y",
"triz-mcp"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for triz-mcp 0.5.1 in an isolated container with no network and no keys. It answered and listed 42 tools.
TRIZ MCP tools 42
Read from the server with tools/listtriz_parameterGet a canonical TRIZ engineering parameter (1-39). Omit id to list all 39.
triz_principleGet a canonical TRIZ inventive principle (1-40). Omit id to list all 40. Look up principle numbers instead of recalling them from memory.
triz_matrixLook up the canonical contradiction matrix for an improving and worsening engineering parameter. Blank and diagonal cells fail closed; never guess a recommendation.
triz_matrix_multiMulti-parameter contradiction lookup: every (improving x worsening) matrix cell with the principles aggregated by how many cells recommend each (ties broken by mean position). Use when a conflict involves several parameters on either side; per-cell detail is returned so nothing is hidden. All-blank or diagonal-only results fail closed like triz_matrix.
triz_resolveLook up a contradiction-matrix cell and expand its recommended principles and both engineering parameters. Fails closed on blank cells.
triz_tool_catalogList the domain-neutral TRIZ tool catalog, optionally restricted to problem analysis, task modeling, or solution synthesis.
triz_effectsSearch the curated effects database by required function (e.g. 'convert temperature difference into voltage', 'store heat', 'sense strain') or list by category: physical, chemical, geometric. Effects are classical textbook phenomena; selecting and substantiating one remains a synthesis step, never a lookup verdict.
triz_routeRoute a problem stage and optional observable signals to candidate TRIZ tools. Routing is deterministic and returns only tools registered for that stage.
triz_build_modelBuild a typed function model from an interaction table: components with stable ids, names and roles, and subject/action/object interactions with explicit carrier descriptors and polarities. Generates readable, stable ports and wire ids: each interaction gets its own input port on its object, `in:<carrier>:<subject>:<action>`, so no input port is fed by two functions (no fan-in, no extensive-fan-in); each subject gets one output port per carrier it sends, `out:<carrier>`, shared by its functions on that carrier (fan-out: one shared level when intensive, the sum of the demands when extensive); each function is the wire `wire:<subject>:<action>:<object>:<carrier>`. Each part is percent-escaped (':' as %3A, '%' as %25), so distinct tuples never share an id. Validates the result, runs lints, and returns a bounded completeness report of unrecorded component pairs, isolation and product reach. Ratings and behavior are never inferred. Optional flows reference component and carrier ids from the table.
triz_expand_hierarchySubstitute one box's declared inner model into its parent through its checked input/output interface. Returns a typed model and fresh box, wire and flow id maps. Preserves inner box costs, feasibility, states and transitions, and standalone inner flows. Parent flow occurrences require explicit routes and checked boundary connections; media need explicit mappings. Inner budgets, weights and contradictions require opt-in global-intersection, global-merge and append-renamed policies. Product-identity changes fail closed. Expand nested boxes one at a time before requesting flat behavior, dynamics or resource verdicts. triz_nine_windows reads a selected box's inner model as its subsystem view.
triz_function_modelCheck a TRIZ function model written as a typed wiring diagram (boxes with typed ports, wires carrying one carrier and a polarity) and analyse it: harm loops (closed loops containing a harmful or excessive function, with witness cycles), an ideality profile per resource dimension (never summed; a scalar ratio only with explicit weights), separation checks for embedded physical contradictions, and, given compare_to, a componentwise baseline-vs-concept comparison plus an isomorphism check: whether the two models share a wiring shape ignoring every id and label (a bijection preserving roles, port sides, shared carriers, wiring, ratings, and costs; decided:false if the bounded search runs out). With mpv_weights (and compare_to), comparison.mpv compares the two models over the main parameters of value only: the named cost dimensions or 'harmful', componentwise and by the explicit weighted sum, listing the other axes on which they differ; a lost deliverable still decides, and no weight is ever filled in. Each verdict cites the theorem in theory/CategoricalTriz.lean it relies on (basis). Any dangling, mis-directed, or mistyped wire, or an invalid embedded contradiction, fails closed with ok:false. Harm loops and separation read the outer wiring and the model's own contradictions only: when boxes declare an `inner` model, incompleteHierarchy lists them, the note says their inner loops and contradictions are not analysed, and the isomorphism check carries incompleteHierarchy: true; run triz_expand_hierarchy on each first. Loops are hypotheses about mechanism to substantiate, not findings.
triz_flowFlow analysis (router entry 16) over the model's declared `flows`: each an ordered path of the boxes a carrier passes through, in series, which functions do not record (two valves in series both act on the water, not on each other). Per flow: its steps (consecutive boxes, with the functions of the flow's carrier between them; declaredOnly counts the steps no function joins); bottleneck candidates (the performer of an insufficient, excessive, or harmful function that carries the flow's carrier and touches the path: a resistance-like output on the flow, at its position); accumulation candidates (a box where the steps of every flow of the carrier converge, with at least two predecessors and fewer successors, or a last box inside the engineered system, role tool or mediator, that no flow of the carrier continues from); leak candidates (a function on the carrier from a box on the path to an environment or supersystem box off it); loops (a box that recurs on the path, with the cycle between occurrences); and the harm loops that meet the path. Every item is a structural candidate to substantiate, not a finding. Boxes consecutive on a flow are adjacent for triz_transform merge. A model that fails the type-check, flows included, fails closed.
Show all 42 toolsShow fewer tools
triz_trimScreen a trimming of one or more boxes by the TRIZ trimming rules: A (object trimmed too, function no longer needed), B (the object performs the function itself), C (another remaining box or supersystem resource has an output of the same carrier). Returns per-function absorbers, orphaned functions that block the trim, harms and costs removed, and one trimming problem per absorber. A carrier match is a necessary condition only; every absorber is a hypothesis to solve and substantiate.
triz_separateDecide whether a physical contradiction's demands can be met piecewise over a finite space x time x condition x direction x level base (the MATRIZ separation types). Each demand lists admissible values and the cells where it applies (omitted axis = whole axis). Returns per-pair status (compatible: not a physical contradiction; separated: the separating axes; irreducible: overlap on every axis) and the conflict cells where no value satisfies every active demand. With `along`, also returns the parameter as a function of that axis alone: the admissible values per cell and whether it must change along the axis (with 'time', the checkable part of Principle 15, Dynamics). Each separated pair also gets `suggestions`, hints and not verdicts: per separating axis, the operations that could build the piecewise system (space: triz_transform segment or take_out; time: standby, or triz_dynamics separation with timed demands, Principle 15; condition: rerate, or a rewrite that changes the field, Principle 28; level: triz_nine_windows, the system operator or its subsystem restriction; direction: segment by port direction), each with the demands' cells on that axis and the looked-up text of the principle it follows. With `certificate: true`, also returns a Lean file that states these separation verdicts about this contradiction and proves them against theory/CategoricalTriz.lean, so Lean can check this one result.
triz_exportExport a function model that type-checks: 'dot' gives Graphviz DOT (each box a table: name and «role» in a role-coloured header, input ports left and output ports right with their carriers, open ports in italics; functions as edges between ports, harmful red, insufficient dashed, excessive bold; flows dotted blue; a legend of what occurs; render with `dot -Tsvg`), 'mermaid' gives a Mermaid flowchart that GitHub, GitLab, and many chat clients render without tools (Mermaid has no ports, so each edge names its out port, in port, and carrier), 'svg' gives a self-contained SVG picture with dot's conventions, laid out by ELK with orthogonal edges, for when Graphviz is not at hand (stdio server only: it needs the optional elkjs package; the hosted server answers ok:false with format-unavailable), 'hypergraph' gives an open hypergraph (ports as carrier-typed vertices, boxes and functions as hyperedges, unwired ports as the interface), 'lean' gives a certificate: a Lean file that encodes the model as finite data and states the kernel's verdicts about it (typing, each harm-loop witness cycle, and the separation verdicts of embedded contradictions), each proved against theory/CategoricalTriz.lean, so Lean can check this one model's verdicts (`certifies` lists them; nothing is extracted). A model that fails the type-check is not exported (ok:false with the errors).
triz_transformApply one typed model transformation and return the new model. Principle constructions: segment (1: divide a box into parts whose ports partition its ports), take_out (2: separate the ports touching a harmful or excessive function, or isolate the part carrying all useful functions), merge (5: collapse adjacent or identical boxes into one; boxes consecutive on a declared flow are adjacent), standby (11: add an unwired typed absorber for a box's functions), reverse (13: swap a function's performer and object), rerate (16: rate a useful function insufficient or excessive; 23: change the level of a function on a cycle), retarget (22: a harmful function's source feeds a useful function), feedback (23: add a function that closes a loop), interpose (24: route a function through a new mediator box), cheap_copy (26, 27: replace a box by a cheaper copy with the same ports). Also trim (perform a typed-feasible trim, re-attaching each kept function to an absorber; rule B is Principle 25, one absorber for everything is Principle 6) and rewrite (delete and add boxes and wires; no remaining wire may touch a deleted box). Every result type-checks or the call fails closed with ok:false. When the segmented box declares behaviour, segment (and take_out) reports behaviourallyIndependent: whether the box's relation is the product of its projections onto the parts; if so each part gets its projection, else no part gets behaviour and each coupled part is named with a witness: two rows whose mix is not a row. It also suggests the finest partition of the box's ports over which its relation is a product (behavior.finest: parts; cut, the suggested blocks the given parts cut, empty iff the split holds; splitsFurther, when nothing is cut, the parts that hold several blocks; decided:false past the cap). interpose's mediator may declare behavior (rows, or 'identity'). A transformation is a structural move, not evidence that it solves the problem: model the result and compare it with triz_function_model compare_to, or with triz_behavior compare_to when behaviour is declared, passing the boxMap that segment, take_out, or cheap_copy returns as box_map. merge renames the merged ports to '<box>.<port>', so no box_map recovers a merged product box's deliverables: they read as lost and regained. reverse returns undo, a rewrite that restores the original model, added ports included.
triz_rule_applyDouble-pushout rewriting with rules as data. A rule is a span L ← K → R of patterns over the function-model schema (boxes with ports typed by carrier variables, and wires); pass it as `rule`, or name a built-in evolution-line rule with `rule_id`: 'mono-bi' (transition to supersystem, mono → bi; apply again for poly), 'feedback' (increasing controllability, self-adjusting with feedback; bind its carrier variable 's' with `carriers`), or 'working-field' (changing the working field: the matched function re-made on another carrier; bind 'd' with `carriers` to a carrier other than the matched one; the result's fieldChanges records both carriers' layer and dimension). Each built-in rule cites the evolution-trends.md line it encodes. `rule_id` 'uneven-development' is a detector, not a rewrite, and takes only the model: the lagging subsystem, a box of the largest harm-loop region that is also on a binding feasibility dimension or limits a deliverable (feasibility finds it unprovidable, or it performs an insufficient function on a product); verdict lagging, none, or undecided (no harm loop, or feasibility undecided). Without `match`: lists every injective match of L (seed it with `at`), each verified as a typed homomorphism and marked applicable when the no-identification and no-dangling conditions hold (a deleted box may not lie on a declared flow) and the rule's `distinct` carrier variables bind different carriers; decided:false if the step budget runs out, complete:false past `limit`. A rule's `forbid` holds negative application conditions (Habel–Pennemann): each pattern extends `left` by id, and a match that extends to an occurrence of one — including any elements the pattern adds — is not applicable; a condition its own step budget cannot decide also refuses the application. With `match` (a listed match, or your own mapping): checks the match, these conditions, and that a kept box keeps the ports its declared rows name (every port for behavior and transition; the named ports for feasibility), then deletes the image of L \ K, glues R \ K under fresh ids, and returns the new model, which type-checks or the call fails closed; deliverableKeysChanged says a deliverable moved to another port or carrier. A rule application is a structural move, not evidence that it helps: compare the result with triz_function_model compare_to.
triz_behaviorCompose declared box behaviour (carrier `values`, box `behavior` rows) into the model's external relation: boundary inputs (unwired input ports) to deliverables (product input ports fed by a non-harmful function). The default upstream scope composes boxes that can reach a deliverable and explicitly assumes omitted boxes accept everything; scope whole composes every box, including downstream and disconnected constraints. full_relation returns all rows within the search cap. Feedback loops compose by the relational trace, so every consistent steady state counts, and the steady states are listed. `factorisations` lists each composed box whose relation is the product of its projections onto two or more groups of ports, with the finest groups, in box order (decided:false past a per-box cap): segment it into them, or unions of them, and each part keeps its projection. The hint describes the declared rows, not a physical split, and changes no verdict. This is steady-state semantics, not dynamics. With `compare_to`, decide whether the model (a concept, e.g. a triz_transform result) has the baseline's input→deliverable relation; pass segment's or take_out's boxMap as `box_map`. `trim` is shorthand: perform the trim as triz_transform does and compare the result with the model. Verdict preserved; changed (a lost deliverable, or a counterexample input with the differing outputs and which relation contains which); or undecided (reason missing-behavior: the boxes that can reach a deliverable and declare no behaviour; reason no-steady-state: neither model has a steady state at any input, so equal empty relations say nothing). With `joint_boxes` and `weakest_spec`, select every composed box without behavior and compute one coupled residual over their combined ports. The joint rows are a single relation: independentSafe checks whether independently declaring their per-box projections stays inside the target, factorizes checks whether their product equals the joint relation, and a counterexample explains unsafe coupling. The exact search is bounded by max_states; row_costs are unsupported in this mode. With `weakest_spec` (and compare_to or trim), give the weakest box specification (residual in Rel) for the one box of the concept that can reach a deliverable and declares no behaviour, against the same target: spec, every row of that box whose composite stays inside the target, with preserves:true when declaring it gives exactly the target (any behaviour that does is contained in it); impossible, when the spec's composite misses part of the target (an uncovered input is given; no behaviour of that box gives the target, and the empty relation, which always stays inside, is never read as preserving) or a deliverable is lost; undecided for three or more unknown boxes when joint_boxes is omitted (several-holes), missing baseline behaviour, an empty target, or past the cap (state-cap). When the box to specify declares `producible` rows (what it can physically produce), the spec is the residual cut down to them: spec when that still covers the target (producible.infeasible lists the residual rows left out); impossible with reason infeasible when the residual covers the target but its producible rows do not, with requiredInfeasible giving, per missing target pair, the residual rows that deliver it, none producible (every relation that gives the target contains one of each); impossible with reason not-covered when the residual itself does not cover. With exactly two boxes without behaviour (boxes), a pair of relations stays inside the target iff every pair of rows, one of each, does, and the maximal such pairs are the formal concepts of the safe row pairs: spec lists those whose composite covers the target (specs, each declared and re-checked to give exactly the target; every pair that gives the target lies inside one), with weakest:true when there is one and weakest:false when several are incomparable; impossible (not-covered) when none covers, with each maximal pair's uncovered input (pairs); undecided (concept-cap) past the cap on concepts. Producible rows cut each box first; impossible with reason infeasible then means some pair over all rows (wouldGive) would give the target. Fails closed on ill-typed behaviour, an ambiguous or mismatched box_map, inputs whose values differ between the models, and past the state cap. With `certificate: true` and compare_to or trim, supported comparisons return a request-bound Lean equality with nonemptiness or an input/output pair belonging to only one relation; declared box_map, one-sided inputs and gained deliverables follow the comparison's baseline interface and selected scope. With row_costs in the one-hole mode, cheapestExtension gives an exact least-cost set of safe nonproducible rows to add, using the complete target relation and explicit integer costs, or reports an undecided capped search; it is not-applicable (target-not-covered-by-residual) when the residual itself misses the target, and row_costs fail with invalid-row-costs wherever no one-box residual is computed; the Boolean verdict is unchanged. The verdict holds for the relations as declared; substantiating them, the absorber's or mediator's first, is outside the kernel.
triz_weaknessRank candidate concepts that declare behaviour by the operating situations they admit (references/weakness.md). A situation is a valuation of the concepts' boundary inputs (unwired input ports, matched by box and port id) over their carriers' declared values: the declared input space is weakness.md's list of operating situations. A concept admits a situation when it has a steady state there and every deliverable output there is acceptable (`acceptable`: per deliverable port, or per carrier for all its deliverables, the values that are, listed or derived from a threshold `at_least`/`below` that is a declared level of the carrier; required for every deliverable; derived sets are listed under acceptable in the result). Give each operating condition the same box and port id in every concept (e.g. an environment box with an unwired input); readByOne lists the inputs only one concept reads. Ranked by set inclusion: weakest (admits everything any other admits), maximal, and every pair as equal, first-weaker, second-weaker, or incomparable, with a situation only one admits each way. The admitted count is a secondary figure: it depends on how finely carrier values are declared. `priors` gives a real prior over the situations (weakness.md: a real prior beats the uniform assumption): per situation input (box and port), or per carrier, a nonnegative weight per declared value (unlisted inputs and values count 1; 0 rules a value out); each concept carries the total prior mass of what it admits (weightedAdmitted, ranked in byWeight), and no inclusion ever moves under weights. `joint_prior` is the alternative for correlated operating conditions: an explicit complete joint table, a weight for every situation (zero allowed), with no independence assumption; it reports jointAdmittedWeight and jointAdmittedProbability per concept, ranked in byJointPrior, separately from inclusion and counts. Give priors or joint_prior, not both. Fails closed when the concepts deliver different ports, an input several read ranges over different values, or acceptable misses a deliverable or names an undeclared value, or a prior is malformed; undecided on missing behaviour or past the state cap. Filter concepts for adequacy first; for safety, integrity, or authorisation decisions admitting more is the wrong direction. With `certificate: true`, also returns a Lean file that encodes each concept's rows and proves every equal, incomparable, or strictly ordered pair: inclusion one way and not the other (AtLeastAsWeak) and the strictly larger count (card_lt_of_strictly_weaker), decided over every valuation; past its cap, `certificate` gives the reason there is none. Prior mass is not certified.
triz_dynamicsBounded dynamics of a function model whose boxes declare `state`, `initial`, and `transition` rows (state, inputs) → (next state, outputs): each such box is a nondeterministic Mealy machine (a lens with a residual is one, with the residual as state); boxes with `behavior` are stateless. Boxes compose synchronously along the wiring: wires are instantaneous, memory lives only in declared state, and a loop through stateless boxes resolves within a step as in triz_behavior. From the initial states, over the boundary inputs you allow at each time (default: every value), every run is explored breadth first up to `horizon` steps; the result lists the reachable states, the fixed points among them, and the runs that block (a state with no row for its inputs). `unsafe` decides escalation: reachable (with a shortest trace), unreachable (the reachable set stopped growing, so at no horizon), or unreachable-within-horizon. `safe` decides invariance: violated (shortest trace), invariant, or invariant-within-horizon. Without `inputs` the configurations are finite, so each verdict also carries `unbounded`, decided at every horizon by continuing the search past the horizon within the same state cap: reachable or violated (with the time and, past the horizon, a shortest trace), unreachable or invariant (with completeAfter), or undecided (cap-exceeded past the horizon, or blocked); the bounded verdict beside it is unchanged. A blocked state meets a target by its state conditions; a port condition there leaves the verdict undecided (reason blocked), never safe. `separation` takes two to four demands, each a target set with a time window, and decides whether one run visits each within its window (separation in time along a trajectory, Principle 15): realizable with a witness trace, unrealizable (a demand never met, or no single run meets them all), or undecided (a blocked run might meet them all). Without `inputs`, `loops` classifies the closed components (no step leaves them) of the reachable graph of the global states of boxes that declare transition, explored without a horizon up to the cap, from the initial states and every state meeting `safe`'s state conditions: bistable (fixed points in two or more closed components), trapped (a closed component every configuration of which meets `unsafe`: an absorbing trap, with a shortest trace into it), recurrent (a closed component that meets `unsafe` and also holds a safe configuration: the run can recover but never leaves it, with a shortest trace into it and the safe configuration), oscillating (a cycle and no fixed point, with its period and one cycle); each closed component reports `unsafe` (it meets the set) and `allUnsafe` (it lies inside it); classes can coexist, and 'none' means no closed component was found within the cap. Behavior rows are never read as transitions. Every trace is re-checked against the declared rows. With `certificate: true`, supported reachable escalations encode and prove their row-derived trace. State-only negative results encode a closed invariant, initial coverage, and unsafe exclusion or safe containment. Saturated unreachable port-target certificates instead exclude admitted unsafe configurations (Sync.target); they do not certify the absence of unsafe blocked states. When the bounded escalation is open and `unbounded` is decided, the certificate states the unbounded verdict (a trace past the horizon, or the unreachable invariant). Input schedules, bounded-only negatives, safe port predicates and loop-class certificates give an explicit unsupported reason. Certificates have source-bound manifests and require independent Lean checking. Fails closed on ill-typed rows, unknown targets, and past the state cap. Verdicts hold for the rows as declared; continuous dynamics, convergence rates, and control are not modelled.
triz_feasibilityMonotone co-design feasibility (Censi 2015) from declared box `feasibility` rows: each row provides a level per output port against the levels it requires per input port and an operating cost, read monotonically (providing less never needs more; more resources never hurt). The product boxes' rows are the demand. An output port feeding several functions meets the largest of their demands on an intensive carrier (the default: one shared level) and their sum on a carrier declared `quantity: extensive`. Composes the rows along non-harmful functions, including feedback loops, by Kleene's ascent from nothing demanded to the least fixpoint, and returns the minimal resource vectors (fixed costs of every box plus the chosen rows' operating costs), each with its rows and demanded levels. Verdict against the model's budget: feasible; infeasible (reason over-budget, with the binding dimensions every minimal vector exceeds, or unprovidable, naming the port no row can serve); or undecided (missing-feasibility, no-budget, unbudgeted). With `trim` and `absorb` (as triz_behavior takes them), apply the trim and decide the trimmed model; the baseline is solved only to report each absorber's added resources. When carriers declare `levels` (thresholds reading amounts as declared values), `levels` reports each feasibility row, of a box that also declares behaviour, whose named amounts read as values no matching behaviour row gives (value-mismatch) or at inputs the behaviour rules out (no-behavior-row). Fails closed on ill-typed or dominated rows, a requirement no non-harmful function supplies, an extensive input fed by several functions (extensive-fan-in: model a merge box), and past the caps. No polynomial bound is claimed. The verdict holds for the rows as declared; the absorber's new harms are not modelled.
triz_abstractionCheck that a coarse function model (few boxes, e.g. with declared behaviour) is an abstraction of a detailed one of the same system (many boxes, e.g. with costs and feasibility) under a typed map: detailed box → coarse box (several may share one; a box left out is outside the abstraction), per box detailed port → coarse port (default: the same id and side), detailed carrier → coarse carrier (default: the same id). A function between two mapped ports is mapped; one between unmapped ports of boxes with the same image is hidden inside that coarse box; one between boxes with different images and an unmapped port is forgotten. Four checks: total (every mapped port's carrier has an image, and every mapped function has an image coarse function with the mapped endpoints, the mapped carrier, and the same polarity class: negative = harmful or excessive, or not), typed (each mapped port lands on a port of the same side whose carrier is its carrier's image, of the same layer; typed_map), wires (every coarse function is the image of a mapped detailed function of its class), harm loops (every coarse harm loop is the image of a detailed one: each harmful or excessive coarse function on it has such a preimage whose object reaches its performer along mapped and hidden functions; cycle_map, with the detailed cycle as witness). Verdict abstraction or not-an-abstraction with the failing checks. Also reports the functions hidden, forgotten, and left out (harms listed apart), the detailed harm loops the coarse model hides or loses, whether reachability among mapped boxes passes to the coarse model (reach_map, when nothing is forgotten), and, where a coarse box with behaviour has one preimage box with feasibility, whether that box's feasibility amounts read through the coarse carriers' levels fall in the coarse behaviour. When either model declares flows, each detailed flow's runs inside the mapped boxes are sent through the map like a merge and matched step by step against the coarse flows of the image carrier (flows.images), and coarse flow steps no detailed step maps to are listed (flows.unbacked); flows do not change the verdict. Fails closed on a model that does not type-check and on map ids that do not exist. Whether the coarse rows are true of their preimages is substantiated outside the kernel.
triz_nine_windowsSystem operator (9 windows) over function models: for past, present, and future, the subsystem view (restriction to the boxes you name, with crossing functions as its boundary), the system view, and the supersystem view (the tool and mediator boxes, or the boxes you list, collapsed into one black box; hidden harmful functions are listed). Each view reports its boxes, function counts, and harm loops. Present is required. Past and future are snapshots with stable box ids, or transitions: triz_transform operations applied in order (past_to_present needs past and must reach present; present_to_future must reach future if given, or derives it). A transition that fails or does not reach its snapshot fails closed. Each transition is reported as one net rewrite step, its part inside the subsystem (which takes the earlier subsystem view to the later one), whether it stays within the subsystem, and the boundary functions it cuts and adds. When the snapshots declare behaviour or feasibility, each time's system view carries its verdicts (system.verdicts) and each change between times says how they move (changes[].verdicts): behaviour compared as triz_behavior compare_to does, weakness ranked with `acceptable`, and feasibility, changed only when both sides are decided; a failure there never fails the grid. When the snapshots declare flows, the verdicts carry each flow's triz_flow candidates, and each change lists the flows added, removed, and re-routed and the candidates each flow gains or loses; a transition must reach the snapshot's flows too, and flowsChanged lists the flows it changes. Missing windows are reported as prompts.
triz_evalsReturn the domain-neutral TRIZ lookup regressions and cross-domain reasoning cases.
triz_subsystem_contractDistinguish a declared subsystem summary from one checked against the complete inner steady-state relation and a single declared resource mode. Verification checks exact behavior over explicit assumptions, nonblocking, levels, demands and budgets; missing data or unsupported modes are undecided. Resource/behavior coupling remains a declared empirical assertion. Caller-supplied checked status is never trusted.
triz_adequacyCheck nonblocking and acceptable outputs over required operating situations under an explicit scope. Equality of two partial relations does not establish adequacy.
triz_isomorphismVerify or search a bijection preserving wiring and declared semantic annotations; search continues past incompatible automorphisms and returns undecided on its global budget.
triz_behavior_refinementCompose two WHOLE models and check exact equality or directional inclusion under explicit boundary and deliverable value maps. Complete relations are checked; no physical transfer is inferred.
triz_subsystem_summaryCompose a stateless subsystem into an exact finite boundary relation with an explicit port map, fixed cost, and hidden-harm list. Empty relations are reported without inventing unknown behavior.
triz_implementationsEvaluate named complete implementations against one whole-model behavior, adequacy, declared-harm and resource contract. Never splice behavior and cost from different modes; provenance remains declared.
triz_absorber_assignmentsEnumerate all compatible absorber endpoints and complete assignments under one finite contract and a shared work budget. Separate per-function successes do not establish joint sufficiency.
triz_synthesizeSearch the Cartesian product of finite behavior/resource alternatives for several stateless holes on fixed wiring. Each complete tuple meets one shared contract; capped search is undecided, impossibility is only within this declared library.
triz_global_separationDecide exact finite global compatibility of allowed tuples on overlapping variable contexts, with a witness or complete empty join. Pairwise projection compatibility alone is insufficient; no cohomology is computed.
triz_queueCompile a finite discrete queue with explicit arrivals, service/storage capacity, schedule and units, then check overflow through existing dynamics. All declared arrival combinations within the schedule are considered.
triz_conservationCheck declared consumptive versus shared-level supply constraints for explicit units. Consumptive branches sum; shared intensive requirements use max. No physical law is inferred from labels.
triz_rule_setValidate a named rule subset and establish termination when every successful application strictly decreases lexicographic box/wire counts. No global confluence or critical-pair completeness is inferred.
triz_rewrite_pairReplay two named structural rewrites in both orders and check whether those occurrences commute. Interference does not prove nonconfluence.
triz_trim_rewriteReturn an applied trim as explicit deletion/gluing data with its declared absorbers, interface, and checked replay. No Kan-extension claim is made.
triz_import_sourceLocal-only import of supplied BOM, OpenAPI, Quint, Lean or Julia inputs. Prefer modelingtoolkit-json and agents-json exports from instantiated Julia models; raw julia is a partial static fallback. Does not fetch references, execute source or load checkpoints. Returns a draft interaction table and model with embedded unconfirmed provenance; review all ratings and assumptions before analysis. Source-code outlines are partial syntactic references, not verified causal or finite behavior models.
triz_review_importLocal-only explicit analyst confirmation of an imported model. Edit the draft first, then confirm every pending id exactly once with decision confirm and optional note. Source locations remain embedded; review asserts the supplied ratings and assumptions, without proving source correctness or physical truth.
triz_graphOptional project extension: analyse an OTSM Network of Problems (contradiction graph) and its verifier-backed purpose gates. A node may carry a PhysicalContradiction; each is checked by separationCheck (irreducible, separable, no-contradiction, or invalid, which fails closed for that node), and the core-conflict ranking breaks ties on dissolves in favour of irreducible nodes and flags a top node that already separates. Requires a project graph via TRIZ_GRAPH; not part of the neutral skill core.
triz_purposeOptional project extension: inspect the invariant, purpose gate, and separation check of one contradiction node of the project graph.
Configuration
TRIZ_DATA_DIRDirectory containing the TRIZ JSON data files; only needed when running outside the packaged layout.
TRIZ_GRAPHOptional path to a project OTSM Network of Problems JSON for the triz_graph tool.
TRIZ_REGISTRYOptional path to a project contradiction registry JSON for purpose verification.
Automated checks
Ran Nov 13, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablesv/triz-skill is public and reachablegithub.com/sv/triz-skill ↗Pass
- Package names this repository as its sourcetriz-mcp names sv/triz-skill as sourcenpmjs.com/package/triz-mcp ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for triz-mcpnpmjs.com/package/triz-mcp/v/0.5.1#provenance ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-01github.com/sv/triz-skill ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from triz-mcpPass
- No critical advisory in the package or its dependencies100 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model51 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubtriz-skill
An agent skill that applies TRIZ to real problems — products, services, processes, organizations, markets, and technical systems — plus a deterministic MCP server so the agent can only cite principles and matrix cells it has looked up, never ones it recalled.
Two parts, usable separately:
| Part | Path | What it is |
|---|---|---|
triz-innovation skill |
skills/triz-innovation/ |
SKILL.md, references, and the canonical JSON knowledge base |
triz MCP server |
src/ |
Read-only stdio MCP server over the same JSON |
Why
An LLM asked for "the TRIZ principles for this contradiction" will produce plausible principle
numbers from memory. The matrix is a lookup table, not a reasoning step, so recall is the wrong
mechanism for it — and a wrong cell silently poisons everything downstream. This repo makes the
lookup deterministic and fail-closed: a blank or diagonal cell returns covered: false with a
pointer to the canonical reference, never a guess.
The skill itself is method, not vocabulary: frame → diagnose → model → synthesize → substantiate, with the matrix used only where both sides of a contradiction credibly map to engineering parameters.
Install the skill
Copy or symlink skills/triz-innovation/ into wherever your agent loads skills from — e.g.
.claude/skills/, .agents/skills/, .codex/skills/, or a $SKILLS_DIR your harness reads:
git clone https://github.com/sv/triz-skill.git
ln -s "$PWD/triz-skill/skills/triz-innovation" ~/.claude/skills/triz-innovation
Once the repo is listed on skills.sh the shorthand becomes
npx skills add sv/triz-skill.
The skill works standalone. The MCP server is what removes recall from the loop.
Run the MCP server
Published package (preferred once released):
npx -y triz-mcp # stdio server, no checkout needed
From a checkout:
pnpm install
pnpm start # stdio server
pnpm test # deterministic lookup regressions
pnpm typecheck
Register it (.mcp.json in this repo is a working example):
{
"mcpServers": {
"triz": {
"type": "stdio",
"command": "npx",
"args": ["tsx", "/path/to/triz-skill/src/server.ts"],
"env": { "TRIZ_DATA_DIR": "/path/to/triz-skill/skills/triz-innovation/data" }
}
}
}
TRIZ_DATA_DIR is only needed when the server runs outside this repo's layout; otherwise the data
dir is resolved relative to the repo root and the server fails closed with a clear message if it is
missing.
Hosted endpoint
src/worker.ts serves the same tools, except the optional triz_graph and triz_purpose and
triz_export format svg, as a Cloudflare Worker over stateless streamable HTTP (deploy with npx wrangler deploy; endpoints
/mcp and /health). It has no authentication and allows any origin (Access-Control-Allow-Origin: *) on purpose: it
is a stateless, read-only public utility with no storage bindings and no secrets, so any client
or web page may drive it. An operator who wants it private can check a token in fetch before
the MCP handler, list allowed origins instead of *, or put it behind Cloudflare Access or a
rate limit. Calling a hosted endpoint sends your model to whoever runs it; keep private models on
the local stdio server.
Tool map
One line per workflow stage; the table below has one row per tool. What each model tool's verdict means, and how to chain the tools, is in categorical-model.md; the theory behind them, and exactly what is and is not claimed, is in docs/theory-map.md.
| Stage | Tools | What they do |
|---|---|---|
| Lookup | triz_parameter, triz_principle, triz_matrix, triz_matrix_multi, triz_resolve, triz_effects, triz_route, triz_tool_catalog, triz_evals |
Read the canonical data: parameters, principles, matrix cells, effects, the method router, and the eval suites |
| Model | triz_build_model, triz_expand_hierarchy, triz_subsystem_contract, triz_function_model, triz_nine_windows, triz_abstraction, triz_export, triz_isomorphism, triz_behavior_refinement, triz_subsystem_summary |
Write the system as a typed function model, view it per level and time, relate coarse and detailed models, draw it |
| Check | triz_function_model, triz_trim, triz_separate, triz_flow, triz_global_separation, triz_queue, triz_conservation |
Type errors, harm loops, ideality; trim candidates; whether a contradiction separates; flow bottlenecks |
| Transform | triz_transform, triz_rule_apply, triz_trim_rewrite, triz_rewrite_pair, triz_rule_set |
Apply one typed move or a rewrite rule; the result type-checks or the call fails closed |
| Decide | triz_behavior, triz_weakness, triz_dynamics, triz_feasibility, triz_adequacy, triz_implementations, triz_absorber_assignments, triz_synthesize |
From declared rows: is behaviour preserved, which concept is weakest, does it escalate, does it fit the budget |
| Relax & rank | triz_feasibility relaxation, triz_pareto |
When the budget says no, the minimal raises that say yes; candidate designs compared jointly, with trade-offs instead of a hidden scalarization |
| Local | triz_import_source, triz_review_import |
Draft models from local sources, then record explicit analyst confirmation |
| Optional | triz_graph, triz_purpose |
A project's own network of problems (stdio server only; see below) |
Tools
| Tool | Purpose |
|---|---|
triz_parameter |
Get one of the 39 engineering parameters with alternate labels and interpretation guidance; omit id to list all |
triz_knowledge |
List universal and domain knowledge packs, provenance, review status and explicit quantity parameters; all packs by default |
triz_principle |
Get one of the 40 inventive principles; omit id to list all |
triz_matrix |
Retrieve a canonical contradiction-matrix cell; blank cells fail closed |
triz_matrix_multi |
Every (improving × worsening) cell for multi-parameter conflicts, aggregated by recommendation frequency |
triz_resolve |
Retrieve a cell and expand its parameters and principles |
triz_tool_catalog |
List the routed TRIZ tool catalog, optionally by stage; entries name the MCP tools (mcp_tools) that carry out their method |
triz_effects |
Search all installed effects packs by function, category or typed quantity; optional domain/pack filters |
triz_effect_setup |
Build a typed model from registered effect ids and explicit finite/resource declarations |
triz_route |
Select candidate tools by stage and observed problem signals |
triz_evals |
Return the neutral lookup and reasoning evaluation suites |
triz_build_model |
Build a typed model from explicitly rated component interactions, with stable ids, lints, and a bounded completeness report |
triz_expand_hierarchy |
Expand an inner model with explicit checked flow routes, media mappings, and opt-in budget, weight and contradiction policies |
triz_subsystem_contract |
Distinguish a declared interface summary from one checked against complete inner behavior and a supported resource mode |
triz_import_source |
Local only (stdio server and triz CLI): draft BOM, OpenAPI, Quint, Lean or Julia inputs with embedded source locations and pending review |
triz_review_import |
Local only (stdio server and triz CLI): confirm every pending rating and assumption while retaining source provenance |
triz_function_model |
Type-check a TRIZ function model (typed wiring diagram); harm loops, ideality per dimension, separation, baseline comparison with an isomorphism check; mpv_weights for a comparison over the main parameters of value |
triz_trim |
Screen trimming by MATRIZ rules A/B/C; carrier-typed absorbers, trimming problems, and level problems for excessive or insufficient functions |
triz_separate |
Decide whether a physical contradiction separates over space, time, condition, direction, or system level; optionally index it by one axis (Principle 15 along time); each separated pair gets suggested operations that could build the separation (hints, not verdicts) |
triz_transform |
Apply one typed move — a construction for one of 13 principles, an applied trim, or a rewrite; fails closed |
triz_rule_apply |
Double-pushout rewriting with rules as data: list a rule's matches, apply one; built-in evolution-line rules (mono → bi, self-adjusting feedback, changing the working field) and the uneven-development detector (the lagging subsystem) |
triz_nine_windows |
System-operator views: subsystem restriction, system, supersystem collapse, per time; transitions between times as checked triz_transform sequences; with declared rows, behaviour, weakness, and feasibility verdict changes between times, and flow candidates when flows are declared; returns the models transitions derive |
triz_export |
Export a model that type-checks as Graphviz DOT, a Mermaid flowchart, a self-contained SVG picture, or an open hypergraph |
triz_behavior |
Compose declared box behaviour into the input→deliverable relation (steady states, relational trace); with compare_to (and box_map), decide whether a concept such as a transform result preserves it; trim is shorthand; joint_boxes computes a coupled multi-box residual with projection-safety checks; one-hole weakest_spec can price missing producible rows using explicit row_costs |
triz_weakness |
Rank modelled concepts by the situations they admit, by inclusion, with incomparable pairs; counts second; acceptable values listed or derived from a threshold through the carrier's levels |
triz_pareto |
Rank candidate designs jointly over declared metric vectors (feasibility resources, lifecycle figures, component counts, costs): the nondominated frontier, dominance witnesses, and trade-offs between incomparable candidates; weights order the listing only |
triz_dynamics |
Bounded runs of boxes with declared state (nondeterministic Mealy machines): escalation into an unsafe set with a shortest trace, invariance of a safe set, separation in time along one run; loops classified as bistable, trapped (inside the unsafe set), recurrent (meets it but can recover), or oscillating |
triz_feasibility |
Monotone co-design (Censi 2015): minimal resource vectors from declared box feasibility, by Kleene's ascent to the least fixpoint; an infeasible verdict also returns relaxation, the nondominated minimal budget raises (each with its row-selection witness) or the smallest per-port capability raises; with trim, decide whether the remaining boxes provide what the trim leaves them within budget, and the absorber's added resources; with carrier levels, the rows that disagree with declared behaviour |
triz_abstraction |
Check that a coarse model is an abstraction of a detailed one under a map of boxes, ports, and carriers: total, typed, every coarse function and harm loop the image of a detailed one; forgotten and hidden harms listed |
triz_flow |
Flow analysis over declared flow paths (boxes in series): per flow, bottleneck, accumulation, and leak candidates, and loops |
triz_graph |
Optional: analyse a project's OTSM Network of Problems (see below) |
triz_adequacy |
Require nonblocking and acceptable outputs at every required operating input |
triz_isomorphism |
Verify or search an annotation-preserving value/state/wiring bijection |
triz_behavior_refinement |
Check exact complete whole-model relation inclusion under an explicit interface/value map |
triz_subsystem_summary |
Compose an exact stateless boundary summary and report hidden harms |
triz_implementations |
Require one named implementation to meet behavior, resources and declared-harm constraints together |
triz_absorber_assignments |
Evaluate complete absorber assignments over every compatible output endpoint |
triz_synthesize |
Search fixed-wiring finite libraries jointly; optional checked symbolic serial maps reduce union trace enumeration |
triz_component_search |
Find components, chains or multi-input assemblies by searching catalogue instances and wiring against typed ports and optional finite property/resource contracts |
triz_component_catalogue |
Get general relations or registered multiport/stateful effect models; configure explicit types and implementation rows |
triz_effect_chains |
Search bounded typed effect chains from explicit resources; hypotheses require substantiation |
triz_lifecycle |
Solve declared maintenance policies and holding costs; ambiguous optimal-policy occupancy remains undecided |
triz_bond_graph |
Check structural effort/flow causality, forced derivative storage and equation dependencies |
triz_effect_insert |
Insert a discovered effect chain into an existing model with explicit bindings and a replayable rewrite |
triz_global_separation |
Find one assignment satisfying every allowed overlapping local relation |
triz_queue |
Compile and check an explicitly scheduled finite queue for overflow |
triz_conservation |
Check declared extensive consumption or shared intensive minimum levels |
triz_rule_set |
Check a sufficient termination measure for a validated named rule subset |
triz_rewrite_pair |
Check whether two named rewrites commute in their two orders |
triz_trim_rewrite |
Return explicit absorber-aware trim data with checked structural replay |
triz_purpose |
Optional: inspect the invariant, purpose gate, and separation check of one graph node |
triz_synthesize preserves exhaustive reference mode and the optimized residual search.
Use strategy: "symbolic" for checked joint finite-map compilation of stateless serial regions before
union traces are enumerated. Typed port permutations, grouped primitives and bounded residual
reuse compound boundary sharing; concrete resource choices remain separate. See
scope, proofs and trust boundary and
measured benchmarks.
For local source import, including exports from instantiated ModelingToolkit and Agents.jl models, see Importing models. Imported models remain drafts through the builder and are refused by analysis until explicitly reviewed.
triz_behavior can specify several unknown boxes jointly: use weakest_spec with joint_boxes
and a target. The result keeps coupling explicit and checks whether its per-box projections are
safe. See Joint weakest specification.
Command line
The package also installs triz, which runs the same tools without an MCP client, for scripts
and agents with a shell. It validates arguments exactly as the server does and prints only JSON
on stdout:
triz list # one line per tool; --json for a JSON array
triz schema triz_behavior # the description and input JSON Schema, as JSON
echo '{"improving": 9, "worsening": 14}' | triz call triz_matrix # or: triz call <tool> args.json
triz call exits 0 with a result, 1 when the result has ok: false (its issues and hints are
still on stdout), and 2 on a usage error or arguments that fail the tool's schema (the issues as
JSON on stderr); --pretty indents the output. Without a global install, run
npx -y -p triz-mcp triz …; from a checkout, node --import tsx src/cli.ts …, or
node dist/cli.js … after pnpm build. triz_graph and triz_purpose read TRIZ_GRAPH and
TRIZ_REGISTRY, as on the server.
TRIZ MCP questions
How do I add TRIZ MCP to Claude Code?
Run claude mcp add triz-skill -- npx -y triz-mcp in your terminal. Add --scope user to make it available in every project.
How do I add TRIZ MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does TRIZ MCP provide?
It exposes 42 tools, including triz_parameter, triz_principle, triz_matrix, triz_matrix_multi, triz_resolve.
Can I run the TRIZ server locally?
Yes, you can run it via stdio using npx or by installing from a checkout using pnpm.
Does the hosted endpoint require authentication?
The hosted Cloudflare Worker endpoint has no authentication and allows any origin to serve as a public utility.