oee-mcp 0.1.0__tar.gz

oee_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Atakan Arikan
+
+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.

oee_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: oee-mcp
+Version: 0.1.0
+Summary: MCP server for oee: Overall Equipment Effectiveness, the six big losses and charts for AI agents.
+Author: Atakan Arikan
+License: MIT
+Project-URL: Homepage, https://github.com/arikanatakan/oee-mcp
+Project-URL: Repository, https://github.com/arikanatakan/oee-mcp
+Project-URL: Issues, https://github.com/arikanatakan/oee-mcp/issues
+Project-URL: Library, https://github.com/arikanatakan/oee
+Keywords: mcp,model-context-protocol,ai-agents,oee,overall-equipment-effectiveness,manufacturing,tpm,teep,six-big-losses,production
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: oee[plot]>=0.1.2
+Requires-Dist: mcp>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+<!-- mcp-name: io.github.arikanatakan/oee-mcp -->
+
+# oee-mcp
+
+[![CI](https://github.com/arikanatakan/oee-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/arikanatakan/oee-mcp/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/oee-mcp?v=2)](https://pypi.org/project/oee-mcp/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+An MCP server that exposes [oee](https://github.com/arikanatakan/oee), the
+Overall Equipment Effectiveness library for Python, as tools for AI agents: give
+it machine times and piece counts and it returns OEE, the time waterfall, the
+six big losses, TEEP, and ready-to-show charts.
+
+Agents asked to compute or report OEE tend to do the arithmetic themselves: a
+performance figure inverted, schedule loss left out, or - the usual mistake -
+OEE figures averaged across machines, which is wrong. Generated OEE fails
+silently. The calculation belongs in a deterministic, versioned, validated
+library that the agent calls, which leaves the agent to choose the analysis and
+explain the result.
+
+## Tools
+
+**Analysis tools** return the library's payload: the factors, the time
+waterfall, the six big losses, TEEP, alerts and provenance.
+
+| Tool | Purpose |
+| ---- | ------- |
+| `compute_oee` | OEE, the waterfall and the six big losses from times and counts |
+| `oee_from_log` | OEE from an event log of production runs and downtime events |
+| `oee_from_factors` | OEE from availability, performance and quality directly |
+| `aggregate_oee` | roll OEE up across machines or shifts correctly (sums the buckets, never averages) |
+| `describe_inputs` | the input fields, units and OEE definitions |
+
+**Chart tools** return a PNG image.
+
+| Tool | Purpose |
+| ---- | ------- |
+| `waterfall_chart` | the OEE time waterfall |
+| `loss_pareto_chart` | a Pareto of the six big losses |
+| `trend_chart` | OEE and the factors over a sequence of shifts |
+
+All tools are read-only.
+
+## Installation
+
+Run it with [uv](https://docs.astral.sh/uv/) (no install needed):
+
+```
+uvx oee-mcp
+```
+
+or install from PyPI:
+
+```
+pip install oee-mcp
+```
+
+## Configuration
+
+Add it to your MCP client. For example:
+
+```json
+{
+  "mcpServers": {
+    "oee": {
+      "command": "uvx",
+      "args": ["oee-mcp"]
+    }
+  }
+}
+```
+
+If you installed with pip, use `"command": "oee-mcp"` with no args.
+
+## Example
+
+```
+compute_oee(machine={
+  "planned_production_time": 420, "downtime": 47, "ideal_rate": 60,
+  "total_count": 19271, "reject_count": 423, "all_time": 480
+})
+  -> { "factors": { "availability": 0.888, "performance": 0.861,
+                    "quality": 0.978, "oee": 0.748, "teep": 0.654 },
+       "summary": "oee - ...\n  OEE 74.8% ..." }
+```
+
+## Design
+
+The server is a thin, stateless wrapper. All of the arithmetic lives in the oee
+library, which computes OEE from the standard definitions and is validated
+against published worked examples (Vorne, TeepTrak) and the Nakajima world-class
+benchmark. The server adds the tool schema, read-only annotations and an
+input-schema helper so an agent can format the input and act on the result.
+
+## Related
+
+- [oee](https://github.com/arikanatakan/oee): the library this server wraps.
+
+## License
+
+MIT. Written and maintained by [Atakan Arikan](https://github.com/arikanatakan),
+MSc Student at Tsinghua University and Politecnico di Milano.

oee_mcp-0.1.0/README.md

@@ -0,0 +1,102 @@
+<!-- mcp-name: io.github.arikanatakan/oee-mcp -->
+
+# oee-mcp
+
+[![CI](https://github.com/arikanatakan/oee-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/arikanatakan/oee-mcp/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/oee-mcp?v=2)](https://pypi.org/project/oee-mcp/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+An MCP server that exposes [oee](https://github.com/arikanatakan/oee), the
+Overall Equipment Effectiveness library for Python, as tools for AI agents: give
+it machine times and piece counts and it returns OEE, the time waterfall, the
+six big losses, TEEP, and ready-to-show charts.
+
+Agents asked to compute or report OEE tend to do the arithmetic themselves: a
+performance figure inverted, schedule loss left out, or - the usual mistake -
+OEE figures averaged across machines, which is wrong. Generated OEE fails
+silently. The calculation belongs in a deterministic, versioned, validated
+library that the agent calls, which leaves the agent to choose the analysis and
+explain the result.
+
+## Tools
+
+**Analysis tools** return the library's payload: the factors, the time
+waterfall, the six big losses, TEEP, alerts and provenance.
+
+| Tool | Purpose |
+| ---- | ------- |
+| `compute_oee` | OEE, the waterfall and the six big losses from times and counts |
+| `oee_from_log` | OEE from an event log of production runs and downtime events |
+| `oee_from_factors` | OEE from availability, performance and quality directly |
+| `aggregate_oee` | roll OEE up across machines or shifts correctly (sums the buckets, never averages) |
+| `describe_inputs` | the input fields, units and OEE definitions |
+
+**Chart tools** return a PNG image.
+
+| Tool | Purpose |
+| ---- | ------- |
+| `waterfall_chart` | the OEE time waterfall |
+| `loss_pareto_chart` | a Pareto of the six big losses |
+| `trend_chart` | OEE and the factors over a sequence of shifts |
+
+All tools are read-only.
+
+## Installation
+
+Run it with [uv](https://docs.astral.sh/uv/) (no install needed):
+
+```
+uvx oee-mcp
+```
+
+or install from PyPI:
+
+```
+pip install oee-mcp
+```
+
+## Configuration
+
+Add it to your MCP client. For example:
+
+```json
+{
+  "mcpServers": {
+    "oee": {
+      "command": "uvx",
+      "args": ["oee-mcp"]
+    }
+  }
+}
+```
+
+If you installed with pip, use `"command": "oee-mcp"` with no args.
+
+## Example
+
+```
+compute_oee(machine={
+  "planned_production_time": 420, "downtime": 47, "ideal_rate": 60,
+  "total_count": 19271, "reject_count": 423, "all_time": 480
+})
+  -> { "factors": { "availability": 0.888, "performance": 0.861,
+                    "quality": 0.978, "oee": 0.748, "teep": 0.654 },
+       "summary": "oee - ...\n  OEE 74.8% ..." }
+```
+
+## Design
+
+The server is a thin, stateless wrapper. All of the arithmetic lives in the oee
+library, which computes OEE from the standard definitions and is validated
+against published worked examples (Vorne, TeepTrak) and the Nakajima world-class
+benchmark. The server adds the tool schema, read-only annotations and an
+input-schema helper so an agent can format the input and act on the result.
+
+## Related
+
+- [oee](https://github.com/arikanatakan/oee): the library this server wraps.
+
+## License
+
+MIT. Written and maintained by [Atakan Arikan](https://github.com/arikanatakan),
+MSc Student at Tsinghua University and Politecnico di Milano.

oee_mcp-0.1.0/oee_mcp/__init__.py

@@ -0,0 +1,5 @@
+"""oee-mcp: the oee Overall Equipment Effectiveness library exposed as MCP tools."""
+
+from ._version import __version__
+
+__all__ = ["__version__"]

oee_mcp-0.1.0/oee_mcp/__main__.py

@@ -0,0 +1,3 @@
+from .server import main
+
+main()

oee_mcp-0.1.0/oee_mcp/_tools.py

@@ -0,0 +1,176 @@
+"""Tool logic, kept free of the MCP SDK so it can be tested directly.
+
+Each analysis tool calls the oee library and returns its JSON-safe payload
+(factors, time waterfall, six big losses, provenance) plus a plain-language
+summary. Chart helpers render a PNG.
+"""
+
+from __future__ import annotations
+
+import io
+
+import matplotlib
+
+matplotlib.use("Agg")
+
+import oee  # noqa: E402
+from pydantic import BaseModel, Field  # noqa: E402
+
+SIGN_AND_UNITS = (
+    "All times must be in the same unit; ideal_cycle_time is that unit per piece "
+    "(or pass ideal_rate in pieces per that unit). Performance above 100% is "
+    "capped and flagged."
+)
+
+DEFINITIONS = [
+    "Availability = run time / planned production time",
+    "Performance = (ideal cycle time x total count) / run time",
+    "Quality = good count / total count",
+    "OEE = Availability x Performance x Quality",
+    "TEEP = OEE x utilization, with utilization = planned production time / all time",
+    "World-class OEE >= 85% (availability >= 90%, performance >= 95%, "
+    "quality >= 99.9%) [Nakajima, 1988]",
+]
+
+SIX_BIG_LOSSES = [
+    "Availability: breakdowns, setup and adjustments",
+    "Performance: minor stops, reduced speed (reported combined)",
+    "Quality: process defects, reduced yield (startup rejects)",
+]
+
+
+class MachineInput(BaseModel):
+    """One machine or shift, by times and piece counts."""
+
+    planned_production_time: float = Field(
+        description="Scheduled production time (any unit, used consistently).")
+    total_count: float = Field(description="Total pieces produced (good and bad).")
+    run_time: float | None = Field(
+        default=None, description="Actual run time; give this or downtime.")
+    downtime: float | None = Field(default=None, description="Stop time within planned time.")
+    ideal_cycle_time: float | None = Field(
+        default=None, description="Time per piece at max speed; give this or ideal_rate.")
+    ideal_rate: float | None = Field(default=None, description="Pieces per time unit at max speed.")
+    good_count: float | None = Field(
+        default=None, description="Good pieces; give this or reject_count.")
+    reject_count: float | None = Field(default=None, description="Rejected pieces.")
+    all_time: float | None = Field(
+        default=None, description="Total calendar time, for TEEP and utilization.")
+    setup_time: float | None = Field(
+        default=None,
+        description="Planned-stop time within downtime; splits availability into "
+        "setup-and-adjustments and breakdowns.")
+    startup_rejects: float | None = Field(
+        default=None,
+        description="Rejects at startup; splits quality into reduced yield and "
+        "process defects.")
+    name: str | None = Field(default=None, description="Optional label.")
+
+
+class ProductionRun(BaseModel):
+    """One production run in an event log."""
+
+    count: float = Field(description="Pieces produced in this run.")
+    good: float | None = Field(default=None, description="Good pieces; give this or reject.")
+    reject: float | None = Field(default=None, description="Rejected pieces.")
+    ideal_cycle_time: float | None = Field(default=None, description="Time per piece at max speed.")
+    ideal_rate: float | None = Field(default=None, description="Pieces per time unit at max speed.")
+
+
+class DowntimeEvent(BaseModel):
+    """One downtime event in an event log."""
+
+    reason: str = Field(description="Reason for the stop.")
+    duration: float = Field(description="Stop duration (same time unit as the runs).")
+    planned: bool = Field(default=False, description="True for planned stops (setup, changeover).")
+
+
+def _payload(result) -> dict:
+    out = result.to_dict()
+    out["summary"] = result.summary()
+    return out
+
+
+def _result(machine: MachineInput):
+    return oee.oee(**machine.model_dump(exclude_none=True))
+
+
+def _png(ax) -> bytes:
+    import matplotlib.pyplot as plt
+
+    buf = io.BytesIO()
+    ax.figure.savefig(buf, format="png", dpi=150, bbox_inches="tight",
+                      facecolor="white")
+    plt.close(ax.figure)
+    return buf.getvalue()
+
+
+def compute_oee(machine: MachineInput) -> dict:
+    """OEE, the time waterfall and the six big losses from times and counts."""
+    try:
+        return _payload(_result(machine))
+    except (ValueError, TypeError) as exc:
+        return {"error": str(exc), "hint": "call describe_inputs for the fields and units"}
+
+
+def oee_from_log(planned_production_time: float, runs: list[ProductionRun],
+                 downtime_events: list[DowntimeEvent] | None = None,
+                 all_time: float | None = None, startup_rejects: float | None = None,
+                 target_oee: float = 0.85, name: str | None = None) -> dict:
+    """OEE from an event log of production runs and downtime events."""
+    try:
+        result = oee.from_log(
+            planned_production_time,
+            runs=[r.model_dump(exclude_none=True) for r in runs],
+            downtime_events=[e.model_dump() for e in downtime_events]
+            if downtime_events else None,
+            all_time=all_time, startup_rejects=startup_rejects,
+            target_oee=target_oee, name=name)
+        return _payload(result)
+    except (ValueError, TypeError, KeyError) as exc:
+        return {"error": str(exc), "hint": "call describe_inputs for the fields and units"}
+
+
+def oee_from_factors(availability: float, performance: float, quality: float,
+                     target_oee: float = 0.85, name: str | None = None) -> dict:
+    """OEE from the three factors directly (each between 0 and 1)."""
+    try:
+        return _payload(oee.oee_from_factors(availability, performance, quality,
+                                             target_oee=target_oee, name=name))
+    except (ValueError, TypeError) as exc:
+        return {"error": str(exc)}
+
+
+def aggregate_oee(machines: list[MachineInput]) -> dict:
+    """Roll OEE up across machines or shifts correctly (sums the buckets)."""
+    try:
+        results = [_result(m) for m in machines]
+        rolled = oee.aggregate(results)
+        out = _payload(rolled)
+        out["machines"] = [{"name": r.name, "oee": r.oee} for r in results]
+        return out
+    except (ValueError, TypeError) as exc:
+        return {"error": str(exc), "hint": "call describe_inputs for the fields and units"}
+
+
+def describe_inputs() -> dict:
+    """The input fields, units and OEE definitions, to format input correctly."""
+    return {
+        "sign_and_units": SIGN_AND_UNITS,
+        "machine_fields": {n: f.description
+                           for n, f in MachineInput.model_fields.items()},
+        "definitions": DEFINITIONS,
+        "six_big_losses": SIX_BIG_LOSSES,
+    }
+
+
+def waterfall_png(machine: MachineInput) -> bytes:
+    return _png(oee.waterfall(_result(machine)))
+
+
+def loss_pareto_png(machine: MachineInput) -> bytes:
+    return _png(oee.losses_pareto(_result(machine)))
+
+
+def trend_png(shifts: list[MachineInput]) -> bytes:
+    return _png(oee.trend([_result(m) for m in shifts], factors=True))

oee_mcp-0.1.0/oee_mcp/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

oee_mcp-0.1.0/oee_mcp/server.py

@@ -0,0 +1,58 @@
+"""The MCP server: registers the oee tools and runs over stdio.
+
+All tools are pure, read-only computations, marked with annotations so a client
+can present and auto-run them safely.
+"""
+
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP, Image
+from mcp.types import ToolAnnotations
+
+from . import _tools
+from ._tools import MachineInput
+
+mcp = FastMCP("oee")
+
+
+def _annotations(title: str) -> ToolAnnotations:
+    return ToolAnnotations(
+        title=title,
+        readOnlyHint=True,
+        idempotentHint=True,
+        openWorldHint=False,
+    )
+
+
+mcp.tool(annotations=_annotations("Compute OEE"))(_tools.compute_oee)
+mcp.tool(annotations=_annotations("OEE from an event log"))(_tools.oee_from_log)
+mcp.tool(annotations=_annotations("OEE from the three factors"))(_tools.oee_from_factors)
+mcp.tool(annotations=_annotations("Aggregate OEE across machines"))(_tools.aggregate_oee)
+mcp.tool(annotations=_annotations("Describe the inputs"))(_tools.describe_inputs)
+
+
+@mcp.tool(annotations=_annotations("OEE waterfall chart (PNG)"))
+def waterfall_chart(machine: MachineInput) -> Image:
+    """Render the OEE time waterfall (planned to fully productive) as a PNG."""
+    return Image(data=_tools.waterfall_png(machine), format="png")
+
+
+@mcp.tool(annotations=_annotations("Loss Pareto chart (PNG)"))
+def loss_pareto_chart(machine: MachineInput) -> Image:
+    """Render a Pareto of the six big losses as a PNG image."""
+    return Image(data=_tools.loss_pareto_png(machine), format="png")
+
+
+@mcp.tool(annotations=_annotations("OEE trend chart (PNG)"))
+def trend_chart(shifts: list[MachineInput]) -> Image:
+    """Render the OEE and A/P/Q trend over a sequence of results as a PNG."""
+    return Image(data=_tools.trend_png(shifts), format="png")
+
+
+def main() -> None:
+    """Console-script entry point: run the server on stdio."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

oee_mcp-0.1.0/oee_mcp.egg-info/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: oee-mcp
+Version: 0.1.0
+Summary: MCP server for oee: Overall Equipment Effectiveness, the six big losses and charts for AI agents.
+Author: Atakan Arikan
+License: MIT
+Project-URL: Homepage, https://github.com/arikanatakan/oee-mcp
+Project-URL: Repository, https://github.com/arikanatakan/oee-mcp
+Project-URL: Issues, https://github.com/arikanatakan/oee-mcp/issues
+Project-URL: Library, https://github.com/arikanatakan/oee
+Keywords: mcp,model-context-protocol,ai-agents,oee,overall-equipment-effectiveness,manufacturing,tpm,teep,six-big-losses,production
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: oee[plot]>=0.1.2
+Requires-Dist: mcp>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+<!-- mcp-name: io.github.arikanatakan/oee-mcp -->
+
+# oee-mcp
+
+[![CI](https://github.com/arikanatakan/oee-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/arikanatakan/oee-mcp/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/oee-mcp?v=2)](https://pypi.org/project/oee-mcp/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+An MCP server that exposes [oee](https://github.com/arikanatakan/oee), the
+Overall Equipment Effectiveness library for Python, as tools for AI agents: give
+it machine times and piece counts and it returns OEE, the time waterfall, the
+six big losses, TEEP, and ready-to-show charts.
+
+Agents asked to compute or report OEE tend to do the arithmetic themselves: a
+performance figure inverted, schedule loss left out, or - the usual mistake -
+OEE figures averaged across machines, which is wrong. Generated OEE fails
+silently. The calculation belongs in a deterministic, versioned, validated
+library that the agent calls, which leaves the agent to choose the analysis and
+explain the result.
+
+## Tools
+
+**Analysis tools** return the library's payload: the factors, the time
+waterfall, the six big losses, TEEP, alerts and provenance.
+
+| Tool | Purpose |
+| ---- | ------- |
+| `compute_oee` | OEE, the waterfall and the six big losses from times and counts |
+| `oee_from_log` | OEE from an event log of production runs and downtime events |
+| `oee_from_factors` | OEE from availability, performance and quality directly |
+| `aggregate_oee` | roll OEE up across machines or shifts correctly (sums the buckets, never averages) |
+| `describe_inputs` | the input fields, units and OEE definitions |
+
+**Chart tools** return a PNG image.
+
+| Tool | Purpose |
+| ---- | ------- |
+| `waterfall_chart` | the OEE time waterfall |
+| `loss_pareto_chart` | a Pareto of the six big losses |
+| `trend_chart` | OEE and the factors over a sequence of shifts |
+
+All tools are read-only.
+
+## Installation
+
+Run it with [uv](https://docs.astral.sh/uv/) (no install needed):
+
+```
+uvx oee-mcp
+```
+
+or install from PyPI:
+
+```
+pip install oee-mcp
+```
+
+## Configuration
+
+Add it to your MCP client. For example:
+
+```json
+{
+  "mcpServers": {
+    "oee": {
+      "command": "uvx",
+      "args": ["oee-mcp"]
+    }
+  }
+}
+```
+
+If you installed with pip, use `"command": "oee-mcp"` with no args.
+
+## Example
+
+```
+compute_oee(machine={
+  "planned_production_time": 420, "downtime": 47, "ideal_rate": 60,
+  "total_count": 19271, "reject_count": 423, "all_time": 480
+})
+  -> { "factors": { "availability": 0.888, "performance": 0.861,
+                    "quality": 0.978, "oee": 0.748, "teep": 0.654 },
+       "summary": "oee - ...\n  OEE 74.8% ..." }
+```
+
+## Design
+
+The server is a thin, stateless wrapper. All of the arithmetic lives in the oee
+library, which computes OEE from the standard definitions and is validated
+against published worked examples (Vorne, TeepTrak) and the Nakajima world-class
+benchmark. The server adds the tool schema, read-only annotations and an
+input-schema helper so an agent can format the input and act on the result.
+
+## Related
+
+- [oee](https://github.com/arikanatakan/oee): the library this server wraps.
+
+## License
+
+MIT. Written and maintained by [Atakan Arikan](https://github.com/arikanatakan),
+MSc Student at Tsinghua University and Politecnico di Milano.

oee_mcp-0.1.0/oee_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+oee_mcp/__init__.py
+oee_mcp/__main__.py
+oee_mcp/_tools.py
+oee_mcp/_version.py
+oee_mcp/server.py
+oee_mcp.egg-info/PKG-INFO
+oee_mcp.egg-info/SOURCES.txt
+oee_mcp.egg-info/dependency_links.txt
+oee_mcp.egg-info/entry_points.txt
+oee_mcp.egg-info/requires.txt
+oee_mcp.egg-info/top_level.txt
+tests/test_server.py
+tests/test_tools.py

oee_mcp-0.1.0/oee_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

oee_mcp-0.1.0/oee_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+oee-mcp = oee_mcp.server:main

oee_mcp-0.1.0/oee_mcp.egg-info/requires.txt

@@ -0,0 +1,7 @@
+oee[plot]>=0.1.2
+mcp>=1.0
+
+[dev]
+pytest>=7
+ruff
+build

oee_mcp-0.1.0/oee_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+oee_mcp

oee_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "oee-mcp"
+version = "0.1.0"
+description = "MCP server for oee: Overall Equipment Effectiveness, the six big losses and charts for AI agents."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Atakan Arikan" }]
+requires-python = ">=3.10"
+dependencies = ["oee[plot]>=0.1.2", "mcp>=1.0"]
+keywords = [
+    "mcp", "model-context-protocol", "ai-agents", "oee",
+    "overall-equipment-effectiveness", "manufacturing", "tpm", "teep",
+    "six-big-losses", "production",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Manufacturing",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.scripts]
+oee-mcp = "oee_mcp.server:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "ruff", "build"]
+
+[project.urls]
+Homepage = "https://github.com/arikanatakan/oee-mcp"
+Repository = "https://github.com/arikanatakan/oee-mcp"
+Issues = "https://github.com/arikanatakan/oee-mcp/issues"
+Library = "https://github.com/arikanatakan/oee"
+
+[tool.setuptools.packages.find]
+include = ["oee_mcp*"]
+
+[tool.ruff]
+line-length = 88
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

oee_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

oee_mcp-0.1.0/tests/test_server.py

@@ -0,0 +1,18 @@
+def test_server_imports_and_wires():
+    from oee_mcp import server
+
+    assert server.mcp is not None
+    assert callable(server.main)
+
+
+def test_all_tools_registered():
+    import asyncio
+
+    from oee_mcp import server
+
+    names = {tool.name for tool in asyncio.run(server.mcp.list_tools())}
+    expected = {
+        "compute_oee", "oee_from_log", "oee_from_factors", "aggregate_oee",
+        "describe_inputs", "waterfall_chart", "loss_pareto_chart", "trend_chart",
+    }
+    assert expected <= names

oee_mcp-0.1.0/tests/test_tools.py

@@ -0,0 +1,68 @@
+import json
+
+import pytest
+
+from oee_mcp import _tools as t
+from oee_mcp._tools import DowntimeEvent, MachineInput, ProductionRun
+
+
+def _vorne():
+    return MachineInput(planned_production_time=420, downtime=47, ideal_rate=60,
+                        total_count=19271, reject_count=423, all_time=480)
+
+
+def test_compute_oee():
+    r = t.compute_oee(_vorne())
+    assert r["factors"]["oee"] == pytest.approx(0.748, abs=0.001)
+    assert r["factors"]["teep"] == pytest.approx(0.654, abs=0.001)
+    assert "summary" in r and "OEE" in r["summary"]
+
+
+def test_compute_oee_error_has_hint():
+    r = t.compute_oee(MachineInput(planned_production_time=420, downtime=47,
+                                   ideal_rate=60, total_count=100))
+    assert "error" in r
+    assert "describe_inputs" in r["hint"]
+
+
+def test_oee_from_log():
+    r = t.oee_from_log(
+        420, runs=[ProductionRun(count=19271, good=18848, ideal_rate=60)],
+        downtime_events=[DowntimeEvent(reason="jam", duration=47)])
+    assert r["factors"]["oee"] == pytest.approx(0.748, abs=0.001)
+    assert r["downtime_reasons"] == {"jam": 47}
+
+
+def test_oee_from_factors():
+    r = t.oee_from_factors(0.90, 0.95, 0.999)
+    assert r["factors"]["oee"] == pytest.approx(0.854, abs=0.001)
+
+
+def test_aggregate_is_not_the_average():
+    m1 = MachineInput(planned_production_time=100, run_time=90, ideal_cycle_time=1,
+                      total_count=80, good_count=80, name="M1")
+    m2 = MachineInput(planned_production_time=300, run_time=150, ideal_cycle_time=1,
+                      total_count=150, good_count=135, name="M2")
+    r = t.aggregate_oee([m1, m2])
+    assert r["factors"]["oee"] == pytest.approx(0.5375, abs=1e-3)
+    assert len(r["machines"]) == 2
+
+
+def test_describe_inputs():
+    d = t.describe_inputs()
+    assert "planned_production_time" in d["machine_fields"]
+    assert d["definitions"]
+    assert d["six_big_losses"]
+
+
+def test_payload_is_json_serializable():
+    json.dumps(t.compute_oee(_vorne()))
+
+
+def test_charts_return_png_bytes():
+    m = MachineInput(planned_production_time=480, downtime=80, ideal_cycle_time=0.5,
+                     total_count=700, reject_count=100, setup_time=30,
+                     startup_rejects=40)
+    for png in (t.waterfall_png(m), t.loss_pareto_png(m), t.trend_png([m, m])):
+        assert isinstance(png, bytes)
+        assert png[:4] == b"\x89PNG"