predikit 0.6.0__tar.gz → 0.6.2__tar.gz

{predikit-0.6.0 → predikit-0.6.2}/.github/workflows/test.yml

@@ -23,24 +23,24 @@ jobs:
         run: pip install -e ".[dev]"
 
       - name: Ruff lint
-        run: ruff check src/ tests/
+        run: ruff check src/ tests/ examples/
 
       - name: Ruff format check
-        run: ruff format --check src/ tests/
-
-      - name: Mypy
-        run: mypy src/predikit
-
-      - name: Build package
-        run: |
-          python -m pip install hatchling
-          python -m hatchling build
-
-  test:
+        run: ruff format --check src/ tests/ examples/
+
+      - name: Mypy
+        run: mypy src/predikit
+
+      - name: Build package
+        run: |
+          python -m pip install hatchling
+          python -m hatchling build
+
+  test:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
 
     steps:
       - uses: actions/checkout@v4

predikit-0.6.2/.gitignore

@@ -0,0 +1,33 @@
+# Byte-compiled / cache
+__pycache__/
+*.py[cod]
+
+# Distribution / packaging
+build/
+dist/
+*.egg
+*.egg-info/
+
+# Virtual environments
+.venv/
+venv/
+
+# Tooling caches
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+
+# Test coverage
+.coverage
+coverage.xml
+htmlcov/
+
+# Serialized models written by examples and CLI tests
+*.joblib
+*.pkl
+
+# MLflow local tracking store
+mlruns/
+
+# Per-developer editor and agent settings
+.claude/settings.local.json

{predikit-0.6.0 → predikit-0.6.2}/CHANGELOG.md

@@ -4,25 +4,55 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
-
-## [0.6.0] - 2026-08-03
-
-### Added
-- MCP server integration via `create_mcp_server()` and `predikit serve`.
-- Optional `mcp` dependency for exposing `ToolRegistry` tools to MCP-compatible clients.
-
-## [0.5.2] - 2026-08-01
-
-### Fixed
-- Repaired the development lockfile so `uv` can resolve the pinned Colorama artifact.
-- Added repository-wide LF line-ending normalization so Ruff formatting is stable across platforms.
-
-### Added
-- Regression coverage for invalid Snowflake output methods and duplicate registry names.
-- CI package-build verification to catch release artifacts that cannot be built.
-
-## [0.5.1] - 2026-07-21
+## [Unreleased]
+
+## [0.6.2] - 2026-08-22
+
+### Added
+- `py.typed` marker, so type checkers actually consume the annotations. Every module is annotated and mypy-clean, and the package declares the `Typing :: Typed` classifier, but without the PEP 561 marker downstream consumers got no type information at all.
+
+### Changed
+- `from_snowflake()` imports `snowflake.ml.registry` inside the function body instead of at module level, matching `from_mlflow()` and the project's own rule for optional dependencies. The module-level `Registry = None` sentinel is gone.
+- CI lints and format-checks `examples/` alongside `src/` and `tests/`.
+
+### Removed
+- `uv.lock`. Nothing consumed it — CI installs with `pip install -e ".[dev]"` — and a library should not pin its consumers' transitive dependencies.
+- `.claude/settings.local.json` from version control. It holds per-developer machine paths.
+
+## [0.6.1] - 2026-08-15
+
+### Fixed
+- MCP tools now advertise an `outputSchema` and return `structuredContent`. The generated callable carried no return annotation, so FastMCP emitted `outputSchema: null` and every result came back as unstructured text. Output fields are named from the tool's `output_name` / `output_description`, and a `collect` ensemble declares each member's output.
+- Low-confidence results keep their `_confidence` and `_low_confidence` keys when served over MCP. The output model allows extra keys; a strict one validates them away silently.
+- `predikit serve` no longer disguises unrelated failures as a bad registry target. Module import and attribute lookup are handled separately, and errors raised while building or running the server propagate with their own traceback instead of being reported as `Could not load registry target`.
+- `coerce_value()` converts `True` / `False` to `1` / `0` for `int` fields. `isinstance(True, int)` is true in Python, so bools previously passed through unconverted.
+
+### Added
+- `--host` and `--port` options on `predikit serve`, plus matching `host` / `port` arguments on `create_mcp_server()`. The `streamable-http` transport was previously stuck on the SDK default of `127.0.0.1:8000`.
+- `ToolRegistry.items()`, `.names()`, `__iter__`, and `__len__` as the public way to enumerate a registry. `create_mcp_server()` used the private `_tools` / `_ensembles` attributes; `to_openai()` and `to_langchain()` now share the same accessor.
+- Python 3.13 in the CI matrix and the package classifiers.
+
+### Changed
+- `mcp` is now a dev dependency, so the MCP integration is tested against the real SDK. The previous tests substituted a fake `FastMCP` and reported full coverage of `mcp.py` while never exercising the SDK — which is how the missing output schema shipped.
+- Test coverage for `predikit serve`, which previously had none.
+
+## [0.6.0] - 2026-08-03
+
+### Added
+- MCP server integration via `create_mcp_server()` and `predikit serve`.
+- Optional `mcp` dependency for exposing `ToolRegistry` tools to MCP-compatible clients.
+
+## [0.5.2] - 2026-08-01
+
+### Fixed
+- Repaired the development lockfile so `uv` can resolve the pinned Colorama artifact.
+- Added repository-wide LF line-ending normalization so Ruff formatting is stable across platforms.
+
+### Added
+- Regression coverage for invalid Snowflake output methods and duplicate registry names.
+- CI package-build verification to catch release artifacts that cannot be built.
+
+## [0.5.1] - 2026-07-21
 
 ### Added
 - Test coverage for the LangChain exporter (`test_exporters_langchain.py`) — previously untested

{predikit-0.6.0 → predikit-0.6.2}/CLAUDE.md

@@ -35,14 +35,14 @@ pip install -e ".[dev]"
 pytest --cov=src/predikit --cov-report=term-missing
 
 # Lint (check only)
-ruff check src/ tests/
+ruff check src/ tests/ examples/
 
 # Format (check only)
-ruff format --check src/ tests/
+ruff format --check src/ tests/ examples/
 
 # Lint + format (auto-fix)
-ruff check --fix src/ tests/
-ruff format src/ tests/
+ruff check --fix src/ tests/ examples/
+ruff format src/ tests/ examples/
 
 # Type check
 mypy src/predikit

{predikit-0.6.0 → predikit-0.6.2}/CONTRIBUTING.md

@@ -30,8 +30,8 @@ This project uses [ruff](https://docs.astral.sh/ruff/) for linting and formattin
 
 ```bash
 # Check and auto-fix
-ruff check --fix src/ tests/
-ruff format src/ tests/
+ruff check --fix src/ tests/ examples/
+ruff format src/ tests/ examples/
 
 # Type check
 mypy src/predikit

{predikit-0.6.0 → predikit-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: predikit
-Version: 0.6.0
+Version: 0.6.2
 Summary: Wrap any trained sklearn/XGBoost model as an LLM-callable tool: auto-generated JSON schemas, Pydantic I/O, OpenAI & LangChain ready, zero boilerplate.
 Project-URL: Homepage, https://github.com/Tejas-TA/predikit
 Project-URL: Repository, https://github.com/Tejas-TA/predikit
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
@@ -33,6 +34,7 @@ Provides-Extra: dev
 Requires-Dist: click>=8.0; extra == 'dev'
 Requires-Dist: joblib>=1.2; extra == 'dev'
 Requires-Dist: langchain-core>=0.1; extra == 'dev'
+Requires-Dist: mcp<2,>=1.28; extra == 'dev'
 Requires-Dist: mlflow>=2.0; extra == 'dev'
 Requires-Dist: mypy>=1.10; extra == 'dev'
 Requires-Dist: pandas>=1.5; extra == 'dev'

{predikit-0.6.0 → predikit-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "predikit"
-version = "0.6.0"
+version = "0.6.2"
 description = "Wrap any trained sklearn/XGBoost model as an LLM-callable tool: auto-generated JSON schemas, Pydantic I/O, OpenAI & LangChain ready, zero boilerplate."
 readme = "README.md"
 license = {text = "MIT"}
@@ -25,6 +25,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
@@ -38,9 +39,9 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-langchain = ["langchain-core>=0.1"]
-mcp = ["mcp>=1.28,<2"]
-xgboost = ["xgboost>=1.7"]
+langchain = ["langchain-core>=0.1"]
+mcp = ["mcp>=1.28,<2"]
+xgboost = ["xgboost>=1.7"]
 mlflow = ["mlflow>=2.0"]
 snowflake = ["snowflake-ml-python>=1.0"]
 cli = ["click>=8.0", "joblib>=1.2"]
@@ -50,6 +51,7 @@ dev = [
     "xgboost>=1.7",
     "langchain-core>=0.1",
     "pandas>=1.5",
+    "mcp>=1.28,<2",
     "mlflow>=2.0",
     "click>=8.0",
     "joblib>=1.2",
@@ -78,9 +80,9 @@ markers = [
     "integration: tests that exercise slower external runtimes or registries",
 ]
 
-[tool.ruff]
-line-length = 100
-target-version = "py310"
+[tool.ruff]
+line-length = 100
+target-version = "py310"
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "UP", "B", "SIM"]

predikit-0.6.2/src/predikit/__init__.py

@@ -0,0 +1,16 @@
+"""Wrap fitted scikit-learn / XGBoost models as LLM-callable tools."""
+
+from .ensemble import ModelEnsemble
+from .exceptions import LowConfidenceError
+from .mcp import create_mcp_server
+from .registry import ToolRegistry
+from .tool import ModelTool
+
+__all__ = [
+    "LowConfidenceError",
+    "ModelEnsemble",
+    "ModelTool",
+    "ToolRegistry",
+    "create_mcp_server",
+]
+__version__ = "0.6.2"

{predikit-0.6.0 → predikit-0.6.2}/src/predikit/cli.py

@@ -60,7 +60,7 @@ if _CLICK_AVAILABLE:
             click.echo(f"Classes:  {meta['classes']}")
 
         if meta["feature_names"]:
-            fields: dict[str, Any] = {f: (float, ...) for f in meta["feature_names"]}
+            fields: dict[str, Any] = dict.fromkeys(meta["feature_names"], (float, ...))
             input_schema = create_model("Input", **fields)
             tool = ModelTool(
                 model=model,
@@ -85,7 +85,19 @@ if _CLICK_AVAILABLE:
         show_default=True,
         help="MCP transport to run.",
     )
-    def serve(registry_target: str, name: str, transport: str) -> None:
+    @click.option(
+        "--host", default=None, help="Bind host for HTTP transports. [default: 127.0.0.1]"
+    )
+    @click.option(
+        "--port", type=int, default=None, help="Bind port for HTTP transports. [default: 8000]"
+    )
+    def serve(
+        registry_target: str,
+        name: str,
+        transport: str,
+        host: str | None,
+        port: int | None,
+    ) -> None:
         """Serve a ToolRegistry from MODULE:ATTRIBUTE over MCP.
 
         ATTRIBUTE may be a ToolRegistry instance or a zero-argument factory.
@@ -93,22 +105,29 @@ if _CLICK_AVAILABLE:
         if ":" not in registry_target:
             raise click.ClickException("REGISTRY_TARGET must use the form MODULE:ATTRIBUTE")
         module_name, attribute_name = registry_target.split(":", 1)
+
+        # Keep this block narrow: it resolves the target only. Errors raised while
+        # building or running the server must surface with their own traceback
+        # rather than be reported as a bad registry target.
         try:
             module = importlib.import_module(module_name)
-            registry = getattr(module, attribute_name)
-            if callable(registry):
-                registry = registry()
-            from .mcp import create_mcp_server
-
-            server = create_mcp_server(registry, name=name)
-            server.run(transport=transport)
         except ImportError as err:
-            raise click.ClickException(str(err)) from err
+            raise click.ClickException(f"Could not import module '{module_name}': {err}") from err
+        try:
+            registry = getattr(module, attribute_name)
         except AttributeError as err:
             raise click.ClickException(
-                f"Could not load registry target '{registry_target}'"
+                f"Module '{module_name}' has no attribute '{attribute_name}'"
             ) from err
 
+        if callable(registry):
+            registry = registry()
+
+        from .mcp import create_mcp_server
+
+        server = create_mcp_server(registry, name=name, host=host, port=port)
+        server.run(transport=transport)
+
 else:
 
     def cli() -> None:  # type: ignore[misc]

{predikit-0.6.0 → predikit-0.6.2}/src/predikit/coerce.py

@@ -8,6 +8,10 @@ _BOOL_FALSE = {"false", "0", "no", "off"}
 
 def coerce_value(value: Any, target_type: type) -> Any:
     """Coerce a single value to target_type with LLM-friendly string handling."""
+    if target_type is int and isinstance(value, bool):
+        # isinstance(True, int) is True, so bools would otherwise pass through unconverted.
+        return int(value)
+
     if isinstance(value, target_type):
         return value
 

{predikit-0.6.0 → predikit-0.6.2}/src/predikit/loaders/snowflake.py

@@ -7,53 +7,48 @@ from pydantic import BaseModel
 
 from ..tool import ModelTool
 
-try:
-    from snowflake.ml.registry import Registry
-except ImportError:
-    Registry = None  # type: ignore[assignment,misc]
-
-
-class _SnowflakeShim:
-    """Wrap a Snowflake Model Registry model as an sklearn estimator."""
-
-    def __init__(
-        self, sf_model: Any, output_method: str = "predict", classes: list | None = None
-    ) -> None:
-        if not callable(getattr(sf_model, output_method, None)):
-            raise AttributeError(
-                f"Snowflake model object has no callable method {output_method!r}."
-            )
-        self._model = sf_model
-        self._method = output_method
-        underlying = getattr(sf_model, "_model_impl", None)
-        if underlying is not None:
-            underlying = getattr(underlying, "sklearn_model", None)
-
-        if classes is None and underlying is not None and hasattr(underlying, "classes_"):
-            classes = list(underlying.classes_)
-
-        if classes is not None:
-            self.classes_ = classes
-
-        if underlying is not None:
-            if hasattr(underlying, "feature_names_in_"):
-                self.feature_names_in_ = underlying.feature_names_in_
-            if hasattr(underlying, "n_features_in_"):
-                self.n_features_in_ = underlying.n_features_in_
-
-    def predict(self, X: Any) -> np.ndarray:
-        result = getattr(self._model, self._method)(X)
-        if hasattr(result, "to_numpy"):
-            return np.asarray(result.to_numpy()).flatten()
-        return np.asarray(result).flatten()
-
-    def predict_proba(self, X: Any) -> np.ndarray:
-        if callable(getattr(self._model, "predict_proba", None)):
-            return np.asarray(self._model.predict_proba(X))
-        raise NotImplementedError(
-            "predict_proba is not available for this Snowflake model object. "
-            "The underlying model may not expose it."
-        )
+
+class _SnowflakeShim:
+    """Wrap a Snowflake Model Registry model as an sklearn estimator."""
+
+    def __init__(
+        self, sf_model: Any, output_method: str = "predict", classes: list | None = None
+    ) -> None:
+        if not callable(getattr(sf_model, output_method, None)):
+            raise AttributeError(
+                f"Snowflake model object has no callable method {output_method!r}."
+            )
+        self._model = sf_model
+        self._method = output_method
+        underlying = getattr(sf_model, "_model_impl", None)
+        if underlying is not None:
+            underlying = getattr(underlying, "sklearn_model", None)
+
+        if classes is None and underlying is not None and hasattr(underlying, "classes_"):
+            classes = list(underlying.classes_)
+
+        if classes is not None:
+            self.classes_ = classes
+
+        if underlying is not None:
+            if hasattr(underlying, "feature_names_in_"):
+                self.feature_names_in_ = underlying.feature_names_in_
+            if hasattr(underlying, "n_features_in_"):
+                self.n_features_in_ = underlying.n_features_in_
+
+    def predict(self, X: Any) -> np.ndarray:
+        result = getattr(self._model, self._method)(X)
+        if hasattr(result, "to_numpy"):
+            return np.asarray(result.to_numpy()).flatten()
+        return np.asarray(result).flatten()
+
+    def predict_proba(self, X: Any) -> np.ndarray:
+        if callable(getattr(self._model, "predict_proba", None)):
+            return np.asarray(self._model.predict_proba(X))
+        raise NotImplementedError(
+            "predict_proba is not available for this Snowflake model object. "
+            "The underlying model may not expose it."
+        )
 
 
 def from_snowflake(
@@ -87,11 +82,13 @@ def from_snowflake(
     Returns:
         A fully configured :class:`~predikit.ModelTool`.
     """
-    if Registry is None:
+    try:
+        from snowflake.ml.registry import Registry
+    except ImportError as exc:
         raise ImportError(
             "snowflake-ml-python is required for from_snowflake(). "
             "Install it with: pip install predikit[snowflake]"
-        )
+        ) from exc
 
     registry = Registry(session=session)
     sf_model = registry.get_model(model_name).version(model_version)

predikit-0.6.2/src/predikit/mcp.py

@@ -0,0 +1,115 @@
+"""MCP server integration for predikit tools."""
+
+from __future__ import annotations
+
+import inspect
+from typing import Any, cast
+
+from pydantic import ConfigDict, Field, create_model
+
+from .registry import ToolRegistry
+
+
+def create_mcp_server(
+    registry: ToolRegistry,
+    name: str = "predikit",
+    host: str | None = None,
+    port: int | None = None,
+) -> Any:
+    """Create an MCP server exposing every tool in ``registry``.
+
+    The MCP dependency is optional. Install it with ``pip install predikit[mcp]``.
+    The returned server uses the SDK's standard transports, including ``stdio``.
+
+    ``host`` and ``port`` configure the HTTP transports; leave them unset to keep
+    the MCP SDK defaults (``127.0.0.1:8000``).
+    """
+    try:
+        from mcp.server.fastmcp import FastMCP
+    except ImportError as err:
+        raise ImportError(
+            "The MCP integration requires the optional dependency. "
+            "Install it with: pip install predikit[mcp]"
+        ) from err
+
+    settings: dict[str, Any] = {"json_response": True}
+    if host is not None:
+        settings["host"] = host
+    if port is not None:
+        settings["port"] = port
+
+    server = FastMCP(name, **settings)
+    for tool in registry.items():
+        server.add_tool(
+            _make_mcp_callable(tool),
+            name=tool.name,
+            description=tool.description,
+        )
+    return server
+
+
+def _output_fields(tool: Any) -> list[tuple[str, str]]:
+    """Return the (name, description) pairs a tool's result dict is keyed by."""
+    tools = getattr(tool, "tools", None)
+    if tools is not None and getattr(tool, "strategy", None) == "collect":
+        # A collect ensemble merges every member's output into one dict.
+        return [(t.output_name, t.output_description) for t in tools]
+    return [(tool.output_name, tool.output_description)]
+
+
+def _make_output_model(tool: Any) -> Any:
+    """Build the return annotation used to advertise a tool's output schema.
+
+    ``extra="allow"`` matters: it keeps the ``_confidence`` / ``_low_confidence``
+    keys that a low-confidence result carries. A model without it validates them
+    away, so MCP clients would silently lose them.
+    """
+    fields = _output_fields(tool)
+    if not all(name.isidentifier() for name, _ in fields):
+        # Output names are user-supplied; fall back to a permissive mapping.
+        return dict[str, Any]
+    definitions: dict[str, Any] = {
+        name: (Any, Field(..., description=desc)) for name, desc in fields
+    }
+    return create_model(
+        f"{tool.name}_output",
+        __config__=ConfigDict(extra="allow"),
+        **definitions,
+    )
+
+
+def _make_mcp_callable(tool: Any) -> Any:
+    """Build a callable whose signature mirrors a tool's Pydantic input model."""
+
+    async def invoke(**kwargs: Any) -> dict:
+        return cast(dict, await tool.ainvoke(kwargs))
+
+    parameters = []
+    annotations: dict[str, Any] = {}
+    for name, field in tool.input_schema.model_fields.items():
+        annotation = field.annotation if field.annotation is not None else Any
+        annotations[name] = annotation
+        default = (
+            inspect.Parameter.empty
+            if field.is_required()
+            else field.get_default(call_default_factory=True)
+        )
+        parameters.append(
+            inspect.Parameter(
+                name,
+                inspect.Parameter.KEYWORD_ONLY,
+                annotation=annotation,
+                default=default,
+            )
+        )
+    # FastMCP derives outputSchema from the return annotation. A bare ``dict`` is
+    # not serializable for structured output, so it must be a concrete model.
+    output_model = _make_output_model(tool)
+    annotations["return"] = output_model
+    invoke.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+        parameters, return_annotation=output_model
+    )
+    invoke.__annotations__ = annotations
+    invoke.__name__ = tool.name
+    invoke.__doc__ = tool.description
+    return invoke

{predikit-0.6.0 → predikit-0.6.2}/src/predikit/registry.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
+
 from .ensemble import ModelEnsemble
 from .tool import ModelTool
 
@@ -26,15 +28,25 @@ class ToolRegistry:
             return self._tools[name]
         if name in self._ensembles:
             return self._ensembles[name]
-        available = list(self._tools) + list(self._ensembles)
+        available = self.names()
         raise KeyError(f"No tool or ensemble named '{name}'. Available: {available}")
 
+    def items(self) -> list[RegistryItem]:
+        """Return every tool followed by every ensemble, in registration order."""
+        return list(self._tools.values()) + list(self._ensembles.values())
+
+    def names(self) -> list[str]:
+        """Return the name of every registered tool and ensemble."""
+        return [item.name for item in self.items()]
+
+    def __iter__(self) -> Iterator[RegistryItem]:
+        return iter(self.items())
+
+    def __len__(self) -> int:
+        return len(self._tools) + len(self._ensembles)
+
     def to_openai(self) -> list[dict]:
-        return [t.to_openai() for t in self._tools.values()] + [
-            e.to_openai() for e in self._ensembles.values()
-        ]
+        return [item.to_openai() for item in self.items()]
 
     def to_langchain(self) -> list:
-        return [t.to_langchain() for t in self._tools.values()] + [
-            e.to_langchain() for e in self._ensembles.values()
-        ]
+        return [item.to_langchain() for item in self.items()]