pyDecision: A Python MCDA Library With a Built-In Web UI

What pyDecision Is For

Multi-criteria decision analysis asks a narrow question: given several alternatives scored against several weighted criteria, which alternative ranks first, and how sensitive is that ranking to the weights? The mathematics is well established, but the implementations are scattered across papers, spreadsheets and one-off scripts. pyDecision collects them into a single Python package. The README lists methods spanning AHP, ANP, BWM, TOPSIS, VIKOR, PROMETHEE I through VI plus Gaia, ELECTRE variants including the Tri families, DEMATEL, CRITIC, Entropy, MAUT, WASPAS, CODAS, MARCOS, SPOTIS and many more, with fuzzy versions of a substantial subset.

The intended audience is stated plainly: researchers, analysts and decision-makers. In practice that means someone who already knows what a consistency ratio is and wants to compute one without writing the eigenvector code. The library also covers a step most packages skip. It compares ranking alternatives and criterion weights across methods, so you can run TOPSIS and VIKOR on the same matrix and see whether they disagree, and it accepts results from custom or not-yet-implemented methods for the same comparison.

A second audience is people who do not want to write Python at all. The README describes pyDecision - MCDA Studio, a web interface, and notes it is aimed at users new to Python who prefer a graphical interface.

How the Library Is Organised and How a Method Runs

The repository layout is flat and conventional: a pyDecision package, an examples directory, setup.py, README.md and LICENSE. Methods are imported from pyDecision.algorithm, with one function per method, as the AHP example shows with ahp_method. The web layer lives in its own subpackage, pyDecision.web, and setup.py lists package_data for that subpackage covering templates, static CSS, JavaScript, images and an examples.json file. That is the clearest evidence in the repository that the web UI is a Flask application serving templates and static assets rather than a separate front end.

The data flow for a method is direct. You build a NumPy array, pass it to the method function along with method-specific parameters, and receive back numeric results. In the AHP case the function returns two values: a weights array and a consistency ratio. The README example prints each weight rounded to three decimals and then branches on whether the ratio exceeds 0.10, printing that the solution is inconsistent and the pairwise comparisons must be reviewed. That threshold is the standard AHP convention and the library leaves the judgement to you rather than raising an error.

Dependencies are heavier than a pure numerical library would need. setup.py requires flask, werkzeug, openai, google-genai, llmx, matplotlib, networkx, numpy, pandas, scipy and scikit-learn. The LLM clients and Flask are there for the interpretation and web features, so a user who only wants TOPSIS still installs the web and AI stack.

Installing pyDecision and Running AHP

Installation is a single pip command, as the README states. There is no conda channel or system package mentioned.

pip install pyDecision

The package version declared in setup.py is 5.1.1. After install, the README's AHP example imports the method by name from pyDecision.algorithm, defines the pairwise comparison matrix as a NumPy array, and calls the function with a weight derivation parameter. The valid values given in the README are 'mean', 'geometric' and 'max_eigen'.

import numpy as np
from pyDecision.algorithm import ahp_method

weight_derivation = 'geometric'

dataset = np.array([
  [1  ,   1/3,   1/5,   1  ,   1/4,   1/2,   3  ],
  [3  ,   1  ,   1/2,   2  ,   1/3,   3  ,   3  ],
  [5  ,   2  ,   1  ,   4  ,   5  ,   6  ,   5  ]
])

weights, rc = ahp_method(dataset, wd = weight_derivation)

The function returns the weight vector and the consistency ratio. You should see one weight per criterion in the order the criteria appear in the matrix. The README's own loop prints them as w(g1), w(g2) and so on. The consistency ratio is the number to check before trusting anything downstream; above 0.10 the README's example says the pairwise comparisons must be reviewed.

If you prefer the graphical route, the README shows that the web service starts and stops from Python itself.

import pyDecision

pyDecision.web_app()
pyDecision.web_stop()

The README also links a Google Colab preview of MCDA Studio but states that the Colab demo is intended for quick demos only and that the best experience is to run the Web UI locally or open it in a full browser.

Where pyDecision Falls Short

The licence is the first thing to resolve. Repository metadata reports NOASSERTION, and setup.py declares license='GNU'. GNU is a family, not a single licence. Nothing in the repository states which one applies, and the LICENSE file at the repository root is the only place that can settle it. For a library that may end up inside a commercial analysis pipeline, that is not a detail to defer.

Release history is the second gap. No releases were retrieved, and the README does not document a changelog, deprecation policy or version compatibility matrix. The version lives in setup.py. If you pin pyDecision in a requirements file, you are pinning against a number that may change without a published release note. Upgrading is therefore a manual diff exercise.

Third, the dependency list creates friction in constrained environments. Flask, werkzeug, openai, google-genai, llmx and scikit-learn are all required at install time even for purely numerical use. In an air-gapped or policy-restricted environment, the LLM client packages alone may block adoption. The README does not describe an install path that omits them.

Finally, breadth is not the same as validation. The README names a very large set of methods, and the presence of a name in that list does not tell you how thoroughly each implementation has been checked. The repository includes an examples directory with files such as polymer_composite_gra.py, remote_monitoring_topsis.py and rural_connectivity_edas.py, which suggests worked cases exist for at least some methods. If your method is not among the examples, you are relying on the method's own literature for correctness.

pyDecision Compared With Building on scikit-criteria

The obvious alternative in the Python ecosystem is a smaller, more focused MCDA package, and scikit-criteria is the one most often reached for. The difference in approach is scope versus surface area. scikit-criteria follows the scikit-learn style of estimator objects with fit and predict style interfaces, which fits naturally into pipelines that already use that idiom, and it covers a narrower set of methods.

pyDecision takes the opposite route. Each method is a plain function that takes arrays and returns arrays, with no estimator abstraction. That makes a single method call shorter to write, as the AHP example shows, but it also means there is no uniform object model to iterate over programmatically. If you want to loop across twenty methods with the same interface, you will write that loop yourself against inconsistent function signatures and parameter names.

Where pyDecision is genuinely differentiated is the comparison layer and the web UI. The README states that the library compares rankings and criterion weights from various methods, and that it can import results from custom methods for the same comparison. A narrower library leaves that to you. The Flask interface is the other differentiator, and it is the reason someone who does not write Python would pick this project over a leaner one. The trade is that you carry Flask, an LLM client stack and a template directory in every install.

Maintenance, Upgrade Cost and Licence

The repository is not archived, and the last push was on 2026-06-03. That is recent enough that the project is not abandoned, but there are no retrieved releases, so the practical upgrade unit is the package version in setup.py rather than a tagged release. Before upgrading, read the diff in the pyDecision package and re-run your own decision matrices, because a change in a weight derivation default or a normalisation step will move rankings without raising an error.

The LLM integration adds a second upgrade surface. Because openai and google-genai are unpinned in setup.py, a fresh install can pull a newer client than the one the code was written against. If you use the interpretation features, test them after any environment rebuild, not only after a pyDecision version bump.

On licensing, setup.py declares GNU and the repository metadata says NOASSERTION. That combination means you cannot determine your obligations from the package metadata alone. Read the LICENSE file at the repository root and, if the terms matter to your organisation, get them reviewed. Nothing here is legal advice, and the repository does not state which GNU licence applies.

Editorial conclusion

Adopt pyDecision if you need several MCDA methods side by side on the same decision matrix and want to compare their rankings and criterion weights without reimplementing each method. Do not adopt it if you need a supported commercial product, a versioned release history, or a permissive licence you can clear without reading the file: setup.py declares GNU and the repository metadata says NOASSERTION. Before you build on it, verify the licence text in LICENSE, confirm the install pulls flask, openai, google-genai and scikit-learn without conflicts in your environment, and check that the method you need is reachable from pyDecision.algorithm rather than only named in the README list.

Frequently asked questions

Official sources

1. Issues
2. README
3. Valdecy/pyDecision on GitHub