rhetor 1.9.2__tar.gz

rhetor-1.9.2/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 University of Edinburgh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rhetor-1.9.2/MANIFEST.in

@@ -0,0 +1,6 @@
+recursive-include pyopl/icon *.png
+recursive-include pyopl *.pyi
+recursive-include pyopl/grammars *
+recursive-include pyopl/opl_models *
+prune test
+global-exclude .DS_Store

rhetor-1.9.2/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: rhetor
+Version: 1.9.2
+Summary: A Python library for parsing and solving OPL-like mathematical programming models using multiple solvers.
+Author-email: Roberto Rossi <robros@gmail.com>
+License: MIT
+Project-URL: Homepage, https://gwr3n.github.io/rhetor/
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: sly>=0.5
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy>=1.14
+Requires-Dist: gurobipy>=11.0
+Requires-Dist: highspy>=1.11
+Requires-Dist: Pillow>=10
+Requires-Dist: PyMuPDF>=1.24
+Requires-Dist: ttkbootstrap>=1.14
+Requires-Dist: platformdirs>=4.1
+Requires-Dist: openai>=1.99
+Requires-Dist: google-generativeai>=0.8.5
+Requires-Dist: google-genai>=1.0.0
+Requires-Dist: ollama>=0.6.0
+Requires-Dist: tensorflow>=2.16.2
+Requires-Dist: sentence-transformers>=5.1.1
+Requires-Dist: tf-keras>=2.16.0
+Requires-Dist: tiktoken>=0.12.0
+Requires-Dist: mcp>=1.27.0
+Requires-Dist: networkx>=3.4
+Dynamic: license-file
+
+# Rhetor
+
+**GenAI-assisted Integrated Modelling Environment for Mixed-Integer Linear Programming**
+
+Rhetor is an Integrated Modelling Environment for modelling and solving mixed-integer linear programming problems. Rhetor supports a subset of the Optimisation Programming Language (OPL) syntax and it is built on [``pyopl``](https://github.com/gwr3n/pyopl), a Python library for parsing and solving OPL-like mathematical programming models using Gurobi or Scipy (Highs). Rhetor integrates GenAI features to support and automate the modelling process.
+
+![Demo](https://github.com/gwr3n/rhetor/raw/main/sudoku.gif)
+
+## Learn More
+
+- [Project Website](https://gwr3n.github.io/rhetor)
+- [Project Repository](https://github.com/gwr3n/rhetor)
+- [PyOPL Repository](https://github.com/gwr3n/pyopl)
+- [PyOPL User Guide](https://github.com/gwr3n/rhetor/blob/main/docs/PyOPL%20user%20guide.md)
+- [Examples Overview](https://github.com/gwr3n/rhetor/blob/main/docs/PyOPL%20examples%20overview.md)
+- [Sample PyOPL Models](https://github.com/gwr3n/rhetor/tree/main/opl_models)

rhetor-1.9.2/README.md

@@ -0,0 +1,230 @@
+# pyopl - Python Optimisation Programming Language
+
+Core package badges:
+
+[![Codecov](https://img.shields.io/codecov/c/gh/gwr3n/pyopl/main)](https://codecov.io/gh/gwr3n/pyopl)
+[![Python package](https://img.shields.io/github/actions/workflow/status/gwr3n/pyopl/python-package.yml?branch=main&label=python%20package)](https://github.com/gwr3n/pyopl/actions/workflows/python-package.yml) 
+[![Lint and type-check](https://img.shields.io/github/actions/workflow/status/gwr3n/pyopl/lint-type.yml?branch=main&label=lint%20%2B%20type-check)](https://github.com/gwr3n/pyopl/actions/workflows/lint-type.yml) 
+[![Rhetor on PyPI](https://img.shields.io/pypi/v/rhetor)](https://pypi.org/project/rhetor/)
+[![Python versions](https://img.shields.io/pypi/pyversions/rhetor)](https://pypi.org/project/rhetor/)
+[![Downloads](https://img.shields.io/pypi/dm/rhetor)](https://pypistats.org/packages/rhetor) 
+[![Release](https://img.shields.io/github/v/release/gwr3n/pyopl)](https://github.com/gwr3n/pyopl/releases) 
+[![Wheel](https://img.shields.io/pypi/wheel/rhetor)](https://pypi.org/project/rhetor/)
+[![License](https://img.shields.io/github/license/gwr3n/pyopl?v=2)](LICENSE.txt)
+
+Quality and tooling:
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000?logo=python)](https://github.com/psf/black) 
+[![Ruff](https://img.shields.io/badge/lint-ruff-1f79ff?logo=python)](https://github.com/astral-sh/ruff) [![mypy](https://img.shields.io/badge/type--checked-mypy-blue?logo=python)](https://github.com/python/mypy) 
+[![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit) 
+[![security: pip-audit](https://img.shields.io/badge/security-pip--audit-008080.svg)](https://github.com/pypa/pip-audit) 
+[![secrets: Betterleaks](https://img.shields.io/badge/secrets-Betterleaks-24292e.svg?logo=github)](https://github.com/betterleaks/betterleaks)
+
+Project/community:
+
+[![Issues](https://img.shields.io/github/issues/gwr3n/pyopl)](https://github.com/gwr3n/pyopl/issues) 
+[![PRs](https://img.shields.io/github/issues-pr/gwr3n/pyopl)](https://github.com/gwr3n/pyopl/pulls) 
+[![Stars](https://img.shields.io/github/stars/gwr3n/pyopl?style=social)](https://github.com/gwr3n/pyopl/stargazers)
+
+Docs:
+
+[![Docs](https://img.shields.io/badge/docs-user%20guide-blue)](docs/PyOPL%20user%20guide.md)
+
+
+`pyopl` is a Python library for parsing and solving OPL-like [1] mathematical programming models using either Gurobi or the open-source SciPy (HiGHS) solver. PyOPL supports a rich subset of Optimisation Programming Language (OPL) syntax for linear and mixed-integer programming.
+
+[1] Van Hentenryck, P. (1999). The OPL optimization programming language. London, England: MIT Press.
+
+## Installation
+
+The GitHub project and importable compiler package are named `pyopl`; the published PyPI distribution is named `rhetor`.
+
+Install via pip (recommended):
+
+```
+pip install rhetor
+```
+
+Or clone the repository and install locally:
+
+```
+git clone https://github.com/gwr3n/pyopl.git
+cd pyopl
+pip install .
+```
+
+Dependencies are managed via `pyproject.toml` and are listed in [`requirements.txt`](./requirements.txt)
+
+PyOPL requires Python 3.10+
+
+You can use either Gurobi or SciPy/HiGHS as the solver. Both solvers are selectable in the API and the Rhetor IME. PyOPL provides robust support for tuple/nested tuple data, advanced boolean logic, implication, and field access in both models and data files.
+
+## Usage
+
+### Solving an OPL Model
+
+You can use the `solve` function to load and solve an OPL model (and optional data file). Choose the solver with the `solver` argument:
+
+```python
+from pyopl import solve
+results = solve('model.mod', 'data.dat', solver='gurobi')  # Use Gurobi (default)
+results = solve('model.mod', 'data.dat', solver='scipy')   # Use SciPy/HiGHS
+```
+
+#### Example
+
+Suppose you have the following files:
+
+- `knapsack.mod` (your OPL model)
+- `knapsack.dat` (your data file)
+
+You can solve the model as follows:
+
+
+```python
+from pyopl import solve
+
+model = "knapsack.mod"
+data = "knapsack.dat"
+
+results = solve(model, data)
+print(results)
+```
+
+
+This will print the parsed AST, the generated solver code, and the solution output from the selected solver. The `solve` function returns a dictionary with the following keys:
+- `status`: The status of the optimization (e.g., 'OPTIMAL', 'INFEASIBLE', etc.)
+- `solution`: A dictionary of variable names and their values (if optimal)
+- `objective_value`: The value of the objective function (if optimal)
+- `stats`: Additional statistics (e.g., MIPGap, Runtime, NodeCount, IterCount)
+- `message`: Any error or status messages
+
+Below, we provide model and data file for our knapsack example.
+
+Example contents for `knapsack.mod`:
+```opl
+// knapsack.mod
+int+ n = ...; // non-negative integer parameter
+float+ c = ...; // non-negative float parameter
+float+ w[1..n] = ...; // indexed parameter
+float+ v[1..n] = ...;
+
+dvar boolean x[1..n];
+
+maximize sum(i in 1..n) v[i] * x[i];
+subject to {
+    sum(i in 1..n) w[i] * x[i] <= c;
+    forall(i in 1..n) x[i] >= 0;
+}
+```
+
+Example contents for `knapsack.dat`:
+```opl
+// knapsack.dat
+n = 4;
+c = 10;
+w = [2, 3, 4, 5];
+v = [3, 4, 5, 6];
+```
+
+See `tools/examples.py` for a repository of examples. 
+
+
+## PyOPL IME
+
+PyOPL includes [Rhetor](https://gwr3n.github.io/rhetor), a GenAI-first integrated modelling environment (IME) for creating, revising, solving, exporting, and versioning OPL models and data files.
+
+![Demo](https://github.com/gwr3n/rhetor/raw/main/sudoku.gif)
+
+The IME features:
+
+- GenAI-first modelling workflows for generating models, revising existing model/data pairs, asking questions about a formulation, and explaining solutions with OpenAI, Google/Gemini, or Ollama models when configured
+- Optional visual prompt attachments for supported GenAI workflows, including images and short PDFs
+- Session-based model version tracking: each run/request can keep a timestamped snapshot that can be previewed, diffed against the current editors, restored, renamed, or deleted
+- Output and session panels for reviewing recent runs, generated artifacts, model/data snapshots, and GenAI interactions
+- Syntax-highlighted model and data editors with open, save, save-as, undo, redo, find, and replace
+- Integrated solve workflow with Gurobi or SciPy/HiGHS selection, solver logs, elapsed-time status, and optional solver-progress display
+- Export support for compiled Python, LP, and MPS artifacts where supported by the selected backend
+- Light/dark themes and configurable editor font sizes, with settings saved between sessions
+
+### Launching the IME
+
+Running PyOPL with no subcommand launches the IME:
+
+```sh
+python -m pyopl
+```
+
+If installed as a package, the `pyopl` console command can be used in place of `python -m pyopl`.
+
+This opens the Rhetor IME window. You can open `.mod` model files and optional `.dat` data files, generate or revise formulations with GenAI assistance, edit them directly, solve them from the interface, export generated artifacts, and choose either Gurobi or SciPy/HiGHS from the Solve menu.
+
+### Sessions and Model Versions
+
+Rhetor keeps an IME session history in a `.pyopl_session` file in the current working directory. Session entries preserve output history and associated model/data snapshots, so you can track how a model changes over an interactive, GenAI-assisted modelling session. From the session list, use the context menu to preview a saved snapshot, diff it against the current editors, restore it into the editors, rename the session entry, or delete it.
+
+
+
+## PyOPL CLI
+
+PyOPL also includes a command-line interface for solving models, exporting generated artifacts, and using GenAI helpers from scripts or terminals.
+
+Basic usage:
+
+```sh
+python -m pyopl solve model.mod data.dat --solver highs --out json
+```
+
+The CLI supports:
+
+- `python -m pyopl solve <model.mod> [data.dat]` to compile and solve a model
+- `--solver highs|gurobi` to choose the backend solver
+- `--out json|py|lp|mps` to print results, export generated Python, or write LP/MPS solver files
+- `--out-file <path>` to write output to a file
+
+Examples:
+
+```sh
+python -m pyopl solve knapsack.mod knapsack.dat --solver highs --out json
+python -m pyopl solve knapsack.mod knapsack.dat --solver highs --out lp --out-file knapsack.lp
+python -m pyopl solve knapsack.mod knapsack.dat --solver highs --out mps --out-file knapsack.mps
+```
+
+
+
+## PyOPL MCP
+
+PyOPL MCP exposes core PyOPL compiler/solver functionality as MCP tools so external clients (IDEs, editors, automation) can call compile, solve, export, and compare operations over stdio-based MCP servers.
+
+- **Purpose**: Provide programmatic access to compilation, solving, Python code export, and model equivalence comparison for OPL models using in-memory model/data strings.
+- **Exposed tools**:
+  - **read_pyopl_grammar_tool**: Return the bundled grammar text.
+  - **solve_strings_tool**: Compile and solve a model from `model_text` and optional `data_text`.
+  - **export_py_strings_tool**: Compile `model_text` and optional `data_text` to generated Python source and return it as a string.
+  - **compare_model_strings_tool**: Compare two OPL models from strings using the same MILP equivalence engine as the IDE's Compare models workflow. Returns `status`, `equivalent`, `level`, `reason`, `proof_steps`, and `counterexample`.
+- **Not exposed as MCP tools**: File-path helpers such as `solve_files_tool` and `export_py_files_tool` are retained in the Python module for trusted local/internal use, but are not registered as MCP tools by default for security reasons.
+- **Solver mapping**: Default solver alias `highs` → SciPy/HiGHS; `gurobi` → Gurobi. See the tool `solver` parameter for selection.
+- **Quick start (VS Code MCP example - .vscode/mcp.json)**:
+```json
+{
+  "servers": {
+    "PyOPL MCP": {
+      "type": "stdio",
+      "command": "${workspaceFolder}/venv/bin/python",
+      "args": ["-m", "pyopl.pyopl_mcp"]
+    }
+  }
+}
+```
+- **Run locally**:
+```bash
+python -m pyopl.pyopl_mcp
+```
+- **Files**: Implementation and tool list in pyopl_mcp.py.
+- **Notes**: Errors from the compiler/solver/comparison engine are propagated to the caller; generated Python code is returned (not written) so the client can persist it as desired.
+
+
+
+## User Guide
+
+A comprehensive [User Guide](docs/PyOPL%20user%20guide.md) is available in the `docs` folder of the repository.

rhetor-1.9.2/RHETOR.md

@@ -0,0 +1,16 @@
+# Rhetor
+
+**GenAI-assisted Integrated Modelling Environment for Mixed-Integer Linear Programming**
+
+Rhetor is an Integrated Modelling Environment for modelling and solving mixed-integer linear programming problems. Rhetor supports a subset of the Optimisation Programming Language (OPL) syntax and it is built on [``pyopl``](https://github.com/gwr3n/pyopl), a Python library for parsing and solving OPL-like mathematical programming models using Gurobi or Scipy (Highs). Rhetor integrates GenAI features to support and automate the modelling process.
+
+![Demo](https://github.com/gwr3n/rhetor/raw/main/sudoku.gif)
+
+## Learn More
+
+- [Project Website](https://gwr3n.github.io/rhetor)
+- [Project Repository](https://github.com/gwr3n/rhetor)
+- [PyOPL Repository](https://github.com/gwr3n/pyopl)
+- [PyOPL User Guide](https://github.com/gwr3n/rhetor/blob/main/docs/PyOPL%20user%20guide.md)
+- [Examples Overview](https://github.com/gwr3n/rhetor/blob/main/docs/PyOPL%20examples%20overview.md)
+- [Sample PyOPL Models](https://github.com/gwr3n/rhetor/tree/main/opl_models)

rhetor-1.9.2/pyopl/__init__.py

@@ -0,0 +1,21 @@
+"""PyOPL package initialization."""
+
+# Ensure 'icon' is a package so importlib.resources works
+import os
+import sys
+
+from .genai.pyopl_generative import generative_feedback, generative_solve
+from .pyopl_core import solve
+
+__version__ = "1.9.2"
+__year__ = "2026"
+__author__ = "Roberto Rossi"
+__email__ = "robros@gmail.com"
+__description__ = "A Python library for parsing and solving OPL-like mathematical programming models using multiple solvers."
+__license__ = "MIT"
+__url__ = "https://github.com/gwr3n/pyopl"
+
+icon_dir = os.path.join(os.path.dirname(__file__), "icon")
+if os.path.isdir(icon_dir) and icon_dir not in sys.path:
+    sys.path.append(icon_dir)
+__all__ = ["solve", "generative_solve", "generative_feedback"]

rhetor-1.9.2/pyopl/__main__.py

@@ -0,0 +1,10 @@
+from .pyopl_cli import main as cli_main
+
+
+def main():
+    # Delegate to the CLI entrypoint which preserves the IDE-as-default behaviour
+    return cli_main()
+
+
+if __name__ == "__main__":
+    main()

rhetor-1.9.2/pyopl/_pyopl_mcp.py

@@ -0,0 +1,307 @@
+"""FastMCP server exposing PyOPL solver functionality as MCP tools.
+
+This module can be run as a standalone server or integrated into an existing
+MCP setup. It exposes tools for:
+
+- solving OPL models from files or strings
+- exporting compiled Python code from OPL inputs
+
+Example VS Code MCP config (.vscode/mcp.json):
+
+{
+  "servers": {
+    "PyOPL MCP": {
+      "type": "stdio",
+      "command": "${workspaceFolder}/venv/bin/python",
+      "args": ["-m", "pyopl.pyopl_mcp"]
+    }
+  },
+  "inputs": []
+}
+"""
+
+from __future__ import annotations
+
+import tempfile
+from importlib.resources import files
+from pathlib import Path
+from typing import Optional, TypeVar, Union
+
+from mcp.server.fastmcp import FastMCP
+
+from . import solve
+from .milp_equivalence import EquivalenceResult, prove_equivalent
+from .pyopl_core import OPLCompiler, linear_problem_from_opl
+
+PathLike = Union[str, Path]
+T = TypeVar("T")
+
+DEFAULT_SOLVER = "highs"
+DEFAULT_PROVIDER = "openai"
+DEFAULT_MODEL = "gpt-5"
+
+METHODS: list[tuple[str, str]] = [
+    ("SyntAGM", "pyopl_generative"),
+    ("Standard", "pyopl_standard"),
+    ("Chain of Thought", "pyopl_chain_of_thought"),
+    ("Tree of Thoughts", "pyopl_tree_of_thoughts"),
+    ("CAFA", "pyopl_cafa"),
+    ("Chain of Experts", "pyopl_chain_of_experts"),
+    ("Reflexion", "pyopl_reflexion"),
+]
+
+mcp = FastMCP("PyOPL MCP")
+
+
+def _read_text(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def _normalize_solver(solver: Optional[str]) -> str:
+    """Normalize solver names for compiler/backend compatibility."""
+    if not solver:
+        return "scipy"
+
+    normalized = solver.strip().lower()
+
+    solver_aliases = {
+        "highs": "scipy",
+        "scipy": "scipy",
+        "gurobi": "gurobi",
+    }
+    return solver_aliases.get(normalized, normalized)
+
+
+def _solve_backend(solver: Optional[str]) -> str:
+    """Normalize solver names for solve() backend selection."""
+    return "gurobi" if _normalize_solver(solver) == "gurobi" else "scipy"
+
+
+def _compile_to_python(
+    model_text: str,
+    data_text: Optional[str] = None,
+    solver: str = DEFAULT_SOLVER,
+) -> str:
+    """Compile OPL model/data text to Python code."""
+    compiler = OPLCompiler()
+    _, code_str, _ = compiler.compile_model(
+        model_text,
+        data_text,
+        solver=_normalize_solver(solver),
+    )
+    return code_str
+
+
+def solve_from_files(
+    model_path: PathLike,
+    data_path: Optional[PathLike] = None,
+    solver: str = DEFAULT_SOLVER,
+) -> dict:
+    """Solve a model from filesystem paths."""
+    model_p = Path(model_path)
+    data_p = Path(data_path) if data_path else None
+    return solve(
+        str(model_p),
+        str(data_p) if data_p else None,
+        solver=_solve_backend(solver),
+    )
+
+
+def solve_from_strings(
+    model_text: str,
+    data_text: Optional[str] = None,
+    solver: str = DEFAULT_SOLVER,
+) -> dict:
+    """Solve a model provided as strings."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        model_file = Path(tmp_dir) / "model.mod"
+        model_file.write_text(model_text, encoding="utf-8")
+
+        data_file: Optional[Path] = None
+        if data_text is not None:
+            data_file = Path(tmp_dir) / "data.dat"
+            data_file.write_text(data_text, encoding="utf-8")
+
+        return solve_from_files(model_file, data_file, solver=solver)
+
+
+def export_py_from_files(
+    model_path: PathLike,
+    data_path: Optional[PathLike] = None,
+    solver: str = DEFAULT_SOLVER,
+) -> str:
+    """Compile a model from files into Python code."""
+    model_code = _read_text(Path(model_path))
+    data_code = _read_text(Path(data_path)) if data_path else None
+    return _compile_to_python(model_code, data_code, solver=solver)
+
+
+def export_py_from_strings(
+    model_text: str,
+    data_text: Optional[str] = None,
+    solver: str = DEFAULT_SOLVER,
+) -> str:
+    """Compile model/data text into Python code."""
+    return _compile_to_python(model_text, data_text, solver=solver)
+
+
+def _equivalence_result_to_dict(result: EquivalenceResult) -> dict:
+    """Convert an equivalence result to an MCP-friendly JSON object."""
+    return {
+        "status": result.status,
+        "equivalent": result.equivalent,
+        "level": result.level,
+        "reason": result.reason,
+        "proof_steps": list(result.proof_steps),
+        "counterexample": result.counterexample,
+    }
+
+
+def compare_model_strings(
+    left_model_text: str,
+    right_model_text: str,
+    left_data_text: Optional[str] = None,
+    right_data_text: Optional[str] = None,
+) -> dict:
+    """Compare two OPL models provided as strings for MILP equivalence."""
+    left_problem = linear_problem_from_opl(left_model_text, left_data_text)
+    right_problem = linear_problem_from_opl(right_model_text, right_data_text)
+    return _equivalence_result_to_dict(prove_equivalent(left_problem, right_problem))
+
+
+def read_pyopl_grammar() -> str:
+    """Return the PyOPL grammar file contents as a UTF-8 string."""
+    return (files(__package__) / "grammars" / "PyOPL grammar.md").read_text(encoding="utf-8")
+
+
+@mcp.tool()
+def read_pyopl_grammar_tool() -> str:
+    """MCP tool returning the PyOPL grammar as a string."""
+    return read_pyopl_grammar()
+
+
+# @mcp.tool()
+def solve_files_tool(
+    model_path: str,
+    data_path: Optional[str] = None,
+    solver: str = DEFAULT_SOLVER,
+) -> dict:
+    """Solve an optimization model from `.mod` and optional `.dat` files.
+
+    Args:
+        model_path: Path to the OPL model file.
+        data_path: Optional path to the OPL data file.
+        solver: Solver name or alias. Supported values currently map to SciPy/HiGHS
+            or Gurobi depending on configuration.
+
+    Returns:
+        A dictionary containing solver outputs (status, objective value, variable
+        assignments, and any solver metadata) as produced by :func:`solve`.
+    """
+    return solve_from_files(model_path, data_path, solver)
+
+
+# @mcp.tool()
+def export_py_files_tool(
+    model_path: str,
+    data_path: Optional[str] = None,
+    solver: str = DEFAULT_SOLVER,
+) -> str:
+    """Compile an OPL model (and optional data) to Python source.
+
+    This tool reads the given `.mod` and optional `.dat` file paths,
+    compiles them to Python using the internal compiler, and returns the
+    generated Python code as a string. It does not write the generated
+    code to disk (the caller may do so).
+
+    Args:
+        model_path: Filesystem path to an OPL model file (.mod).
+        data_path: Optional path to an OPL data file (.dat).
+        solver: Solver name or alias influencing backend codegen.
+
+    Returns:
+        A string containing the compiled Python source.
+
+    Raises:
+        Exceptions from the compiler (syntax/semantic errors) or I/O
+        errors reading the input files are propagated.
+    """
+    return export_py_from_files(model_path, data_path, solver)
+
+
+@mcp.tool()
+def solve_strings_tool(
+    model_text: str,
+    data_text: Optional[str] = None,
+    solver: str = DEFAULT_SOLVER,
+) -> dict:
+    """Solve an OPL model and optional data provided as strings.
+
+    Args:
+        model_text: OPL model source code as a string.
+        data_text: Optional OPL data file contents as a string.
+        solver: Solver name or alias. This maps to the internal solver
+            backends (for example, ``highs`` -> SciPy/HiGHS or ``gurobi``).
+
+    Returns:
+        A dictionary containing solver outputs (status, objective value,
+        variable assignments, and any solver metadata) as produced by
+        :func:`solve`.
+    """
+    return solve_from_strings(model_text, data_text, solver)
+
+
+@mcp.tool()
+def export_py_strings_tool(
+    model_text: str,
+    data_text: Optional[str] = None,
+    solver: str = DEFAULT_SOLVER,
+) -> str:
+    """Compile OPL model and optional data provided as strings to Python.
+
+    Useful for programmatic use where model/data are held in memory. The
+    function returns the compiled Python source as a string.
+
+    Args:
+        model_text: OPL model source as a string.
+        data_text: Optional OPL data contents as a string.
+        solver: Solver name or alias affecting code generation.
+
+    Returns:
+        A string with the compiled Python source.
+
+    Raises:
+        Compilation errors or other exceptions raised by the internal
+        compiler are propagated to the caller.
+    """
+    return export_py_from_strings(model_text, data_text, solver)
+
+
+@mcp.tool()
+def compare_model_strings_tool(
+    left_model_text: str,
+    right_model_text: str,
+    left_data_text: Optional[str] = None,
+    right_data_text: Optional[str] = None,
+) -> dict:
+    """Compare two OPL models provided as strings for MILP equivalence.
+
+    This exposes the same comparison engine used by the GUI's Compare models
+    workflow, but avoids filesystem paths by accepting model/data contents
+    directly.
+
+    Args:
+        left_model_text: OPL source for the left model.
+        right_model_text: OPL source for the right model.
+        left_data_text: Optional OPL data contents for the left model.
+        right_data_text: Optional OPL data contents for the right model.
+
+    Returns:
+        A dictionary containing status, equivalent, level, reason, proof_steps,
+        and counterexample fields.
+    """
+    return compare_model_strings(left_model_text, right_model_text, left_data_text, right_data_text)
+
+
+if __name__ == "__main__":
+    mcp.run()