inventree-mcp 0.1.0__tar.gz

inventree_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Oliver Walters <admin@inventree.org>
+
+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.

inventree_mcp-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include inventree_mcp/static *

inventree_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: inventree-mcp
+Version: 0.1.0
+Summary: MCP server for InvenTree
+Author-email: Oliver Walters <admin@inventree.org>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/inventree/inventree-mcp
+Keywords: inventree,plugin
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: InvenTree
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<3,>=2.0
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+Dynamic: license-file
+
+# InvenTreeMCP
+
+[![CI](https://github.com/inventree/inventree-mcp/actions/workflows/ci.yaml/badge.svg)](https://github.com/inventree/inventree-mcp/actions/workflows/ci.yaml)
+[![codecov](https://codecov.io/gh/inventree/inventree-mcp/graph/badge.svg)](https://codecov.io/gh/inventree/inventree-mcp)
+
+An MCP (Model Context Protocol) server for InvenTree, exposed as an InvenTree plugin. It lets MCP
+clients (Claude, other MCP-aware agents) query InvenTree inventory data over a Streamable HTTP
+endpoint.
+
+## Design
+
+Every tool is a thin wrapper around InvenTree's own REST API view classes (see
+[`inventree_mcp/proxy.py`](inventree_mcp/proxy.py)), dispatched as the authenticated caller - MCP
+requests go through exactly the same permission checks, filtering, and serialization as the regular
+REST API. Tool code never queries the Django ORM directly.
+
+Currently read-only, covering parts, stock items/locations, part categories, purchase/sales/return/
+build orders (with line items and allocations), companies, contacts, addresses, manufacturer/
+supplier parts, BOM items, attachments, parameters, stock tracking history, test results, and
+project codes. Once write tools land, the `MCP_READ_ONLY` setting (see Configuration) will block
+them by default regardless of the calling user's permissions.
+
+Each tool's `outputSchema` and filter/ordering options are derived live from InvenTree's own
+serializers and views (not hand-maintained), so they can't drift as InvenTree evolves. Call
+`describe_filters(resource)` to see what's available for a given resource. The set of tools an MCP
+client sees is also filtered to what the calling user can actually use - though every call is still
+permission-checked in full regardless of what was advertised.
+
+## Setup
+
+### 1. Install the plugin
+
+Install via the InvenTree plugin manager, or via pip:
+
+```bash
+pip install inventree-mcp
+```
+
+Then enable the plugin under **Admin > Plugins**, and configure its settings (see
+Configuration below).
+
+### 2. Create a token for your MCP client
+
+Create an InvenTree API token for your MCP client.
+
+### 3. Configure your MCP client
+
+The endpoint is `<your-inventree-server>/plugin/inventree-mcp/mcp/`, using Streamable HTTP
+transport with an `Authorization: Token <token>` header.
+
+For a client that supports remote Streamable HTTP servers directly, add:
+
+```json
+{
+  "mcpServers": {
+    "inventree": {
+      "url": "https://<your-inventree-server>/plugin/inventree-mcp/mcp/",
+      "headers": {
+        "Authorization": "Token <your-api-token>"
+      }
+    }
+  }
+}
+```
+
+For a client that only supports local (stdio) servers, bridge it with
+[`mcp-remote`](https://www.npmjs.com/package/mcp-remote):
+
+```json
+{
+  "mcpServers": {
+    "inventree": {
+      "command": "npx",
+      "args": [
+        "mcp-remote",
+        "https://<your-inventree-server>/plugin/inventree-mcp/mcp/",
+        "--header",
+        "Authorization: Token <your-api-token>"
+      ]
+    }
+  }
+}
+```
+
+## Configuration
+
+Under **Settings > Plugin Settings**:
+
+- **Require Authentication** (`REQUIRE_AUTH`, default `True`): reject unauthenticated requests.
+  Only disable for local testing.
+- **Read Only** (`MCP_READ_ONLY`, default `True`): block all write actions via MCP, regardless of
+  the calling user's permissions. A plugin-wide kill switch, independent of per-user roles.
+
+## Authentication
+
+Access follows the calling user's normal InvenTree role assignments. Supported auth methods:
+
+- An InvenTree API token: `Authorization: Token <token>`.
+- Basic auth (username/password).
+- An OAuth2 bearer token: `Authorization: Bearer <token>`. A scoped token (e.g. `r:view:part`)
+  narrows access *below* the underlying user's roles - useful for issuing an agent a tightly-scoped
+  token without creating a separate low-privilege user.
+
+Session/cookie auth is not supported (not meaningful for a machine client).

inventree_mcp-0.1.0/README.md

@@ -0,0 +1,104 @@
+# InvenTreeMCP
+
+[![CI](https://github.com/inventree/inventree-mcp/actions/workflows/ci.yaml/badge.svg)](https://github.com/inventree/inventree-mcp/actions/workflows/ci.yaml)
+[![codecov](https://codecov.io/gh/inventree/inventree-mcp/graph/badge.svg)](https://codecov.io/gh/inventree/inventree-mcp)
+
+An MCP (Model Context Protocol) server for InvenTree, exposed as an InvenTree plugin. It lets MCP
+clients (Claude, other MCP-aware agents) query InvenTree inventory data over a Streamable HTTP
+endpoint.
+
+## Design
+
+Every tool is a thin wrapper around InvenTree's own REST API view classes (see
+[`inventree_mcp/proxy.py`](inventree_mcp/proxy.py)), dispatched as the authenticated caller - MCP
+requests go through exactly the same permission checks, filtering, and serialization as the regular
+REST API. Tool code never queries the Django ORM directly.
+
+Currently read-only, covering parts, stock items/locations, part categories, purchase/sales/return/
+build orders (with line items and allocations), companies, contacts, addresses, manufacturer/
+supplier parts, BOM items, attachments, parameters, stock tracking history, test results, and
+project codes. Once write tools land, the `MCP_READ_ONLY` setting (see Configuration) will block
+them by default regardless of the calling user's permissions.
+
+Each tool's `outputSchema` and filter/ordering options are derived live from InvenTree's own
+serializers and views (not hand-maintained), so they can't drift as InvenTree evolves. Call
+`describe_filters(resource)` to see what's available for a given resource. The set of tools an MCP
+client sees is also filtered to what the calling user can actually use - though every call is still
+permission-checked in full regardless of what was advertised.
+
+## Setup
+
+### 1. Install the plugin
+
+Install via the InvenTree plugin manager, or via pip:
+
+```bash
+pip install inventree-mcp
+```
+
+Then enable the plugin under **Admin > Plugins**, and configure its settings (see
+Configuration below).
+
+### 2. Create a token for your MCP client
+
+Create an InvenTree API token for your MCP client.
+
+### 3. Configure your MCP client
+
+The endpoint is `<your-inventree-server>/plugin/inventree-mcp/mcp/`, using Streamable HTTP
+transport with an `Authorization: Token <token>` header.
+
+For a client that supports remote Streamable HTTP servers directly, add:
+
+```json
+{
+  "mcpServers": {
+    "inventree": {
+      "url": "https://<your-inventree-server>/plugin/inventree-mcp/mcp/",
+      "headers": {
+        "Authorization": "Token <your-api-token>"
+      }
+    }
+  }
+}
+```
+
+For a client that only supports local (stdio) servers, bridge it with
+[`mcp-remote`](https://www.npmjs.com/package/mcp-remote):
+
+```json
+{
+  "mcpServers": {
+    "inventree": {
+      "command": "npx",
+      "args": [
+        "mcp-remote",
+        "https://<your-inventree-server>/plugin/inventree-mcp/mcp/",
+        "--header",
+        "Authorization: Token <your-api-token>"
+      ]
+    }
+  }
+}
+```
+
+## Configuration
+
+Under **Settings > Plugin Settings**:
+
+- **Require Authentication** (`REQUIRE_AUTH`, default `True`): reject unauthenticated requests.
+  Only disable for local testing.
+- **Read Only** (`MCP_READ_ONLY`, default `True`): block all write actions via MCP, regardless of
+  the calling user's permissions. A plugin-wide kill switch, independent of per-user roles.
+
+## Authentication
+
+Access follows the calling user's normal InvenTree role assignments. Supported auth methods:
+
+- An InvenTree API token: `Authorization: Token <token>`.
+- Basic auth (username/password).
+- An OAuth2 bearer token: `Authorization: Bearer <token>`. A scoped token (e.g. `r:view:part`)
+  narrows access *below* the underlying user's roles - useful for issuing an agent a tightly-scoped
+  token without creating a separate low-privilege user.
+
+Session/cookie auth is not supported (not meaningful for a machine client).

inventree_mcp-0.1.0/inventree_mcp/__init__.py

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

inventree_mcp-0.1.0/inventree_mcp/context.py

@@ -0,0 +1,78 @@
+"""Propagate the authenticated Django user (and OAuth2 auth, if any) into MCP tool execution.
+
+Tool functions are invoked by the MCP SDK's dispatcher, which does not know
+about Django requests. The transport view sets the current identity via a
+contextvar before handing the request off to the MCP session manager, so
+tools (and the proxy layer) can recover *who* is calling without threading a
+request object through every tool signature.
+"""
+
+from __future__ import annotations
+
+from contextvars import ContextVar, Token
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import AbstractUser
+
+
+@dataclass(frozen=True)
+class _Identity:
+    user: AbstractUser
+    # The real oauth2_provider AccessToken, if the MCP request itself was
+    # OAuth2-authenticated - None for token/basic/session auth. Propagated so
+    # proxy.call_view() can make the proxied view see the token's *actual*
+    # granted scopes, not just the user's role permissions. See proxy.py.
+    oauth2_token: Any | None = None
+
+
+_current_identity: ContextVar[_Identity | None] = ContextVar(
+    "inventree_mcp_current_identity", default=None
+)
+
+
+def set_current_user(
+    user: AbstractUser | None, oauth2_token: Any | None = None
+) -> Token:
+    """Bind *user* (and, if OAuth2-authenticated, the real access token) for this context."""
+    identity = _Identity(user, oauth2_token) if user is not None else None
+    return _current_identity.set(identity)
+
+
+def reset_current_user(token: Token) -> None:
+    """Undo a prior set_current_user call."""
+    _current_identity.reset(token)
+
+
+def has_current_user() -> bool:
+    """Return whether a user is currently bound, without raising if not.
+
+    For code that needs to behave differently outside a real MCP request
+    (e.g. tool_visibility.py, which can't run a permission check without a
+    caller to check permissions *for*) rather than treat "no caller" as a
+    fatal error the way get_current_user() deliberately does everywhere else.
+    """
+    identity = _current_identity.get()
+    return identity is not None and identity.user.is_authenticated
+
+
+def get_current_user() -> AbstractUser:
+    """Return the user bound to the current MCP request.
+
+    Raises:
+        PermissionError: if no user is bound (e.g. a tool is invoked outside
+            of a real MCP request, or authentication was not enforced).
+    """
+    identity = _current_identity.get()
+
+    if identity is None or not identity.user.is_authenticated:
+        raise PermissionError("No authenticated user for this MCP request")
+
+    return identity.user
+
+
+def get_current_oauth2_token() -> Any | None:
+    """Return the real OAuth2 access token for the current MCP request, if any."""
+    identity = _current_identity.get()
+    return identity.oauth2_token if identity else None

inventree_mcp-0.1.0/inventree_mcp/core.py

@@ -0,0 +1,59 @@
+"""MCP server for InvenTree"""
+
+from typing import ClassVar
+
+from plugin import InvenTreePlugin
+from plugin.mixins import SettingsMixin, UrlsMixin
+
+from . import PLUGIN_VERSION
+
+
+class InvenTreeMCP(SettingsMixin, UrlsMixin, InvenTreePlugin):
+    """InvenTreeMCP - custom InvenTree plugin."""
+
+    # Plugin metadata
+    TITLE = "InvenTree MCP"
+    NAME = "InvenTreeMCP"
+    SLUG = "inventree-mcp"
+    DESCRIPTION = "MCP server for InvenTree"
+    VERSION = PLUGIN_VERSION
+
+    # Additional project information
+    AUTHOR = "Oliver Walters"
+    WEBSITE = "https://github.com/inventree/inventree-mcp"
+    LICENSE = "MIT"
+
+    # Optionally specify supported InvenTree versions
+    # MIN_VERSION = '0.18.0'
+    # MAX_VERSION = '2.0.0'
+
+    # Plugin settings (from SettingsMixin)
+    # Ref: https://docs.inventree.org/en/latest/plugins/mixins/settings/
+    SETTINGS: ClassVar[dict] = {
+        "REQUIRE_AUTH": {
+            "name": "Require Authentication",
+            "description": "Reject unauthenticated requests to the MCP endpoint. Disable only for local testing.",
+            "validator": bool,
+            "default": True,
+        },
+        "MCP_READ_ONLY": {
+            "name": "Read Only",
+            "description": "Block all write actions via the MCP endpoint, regardless of the calling user's permissions.",
+            "validator": bool,
+            "default": True,
+        },
+        "MCP_LOG_TOOL_CALLS": {
+            "name": "Log Tool Calls",
+            "description": "Log every MCP tool call (tool name, arguments, calling user, and outcome) to the 'inventree' logger for debugging.",
+            "validator": bool,
+            "default": False,
+        },
+    }
+
+    # Custom URL endpoints (from UrlsMixin)
+    # Ref: https://docs.inventree.org/en/latest/plugins/mixins/urls/
+    def setup_urls(self):
+        """Configure custom URL endpoints for this plugin."""
+        from .mcp_transport import urlpatterns
+
+        return urlpatterns

inventree_mcp-0.1.0/inventree_mcp/expand_introspection.py

@@ -0,0 +1,49 @@
+"""Describe a view's optional output-expansion flags (e.g. `part_detail`).
+
+Many InvenTree list/detail views can inline a related object's full detail
+into the response on request (`?part_detail=true` on the stock API embeds
+the full Part, avoiding a separate get_part call) rather than only exposing
+its ID. These flags are declared once per view as `output_options`, an
+`InvenTree.fields.OutputConfiguration` subclass listing `InvenTreeOutputOption`
+instances (flag name, default, description) - the same metadata InvenTree's
+own OpenAPI schema is generated from (see `InvenTree.schema.
+schema_for_view_output_options`). Reading it here means this can't drift
+from the real API the way a hand-maintained list per resource would.
+
+Not every view declares `output_options` (flat resources with no
+expandable relations, e.g. Company, Attachment, don't need it) -
+describe_output_options() returns an empty dict for those rather than
+raising, same permissive spirit as filter_introspection.py.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def describe_output_options(view_cls: type) -> dict[str, Any]:
+    """Describe the optional output-expansion flags available on *view_cls*.
+
+    Args:
+        view_cls: a list or detail view class as used in the real API
+            urlconf (e.g. stock.api.StockList or stock.api.StockDetail).
+            Both a resource's list and detail view conventionally share the
+            same `output_options` class, so either works.
+
+    Returns:
+        A dict of {flag_name: {default_included, description}} - each key
+        is a boolean query parameter that can be passed directly in a
+        list/get tool's `filters` argument, e.g. filters={"part_detail": true}.
+        Empty if the view declares no `output_options`.
+    """
+    output_config = getattr(view_cls, "output_options", None)
+    if output_config is None:
+        return {}
+
+    return {
+        option.flag: {
+            "default_included": bool(option.default),
+            "description": option.description,
+        }
+        for option in output_config.OPTIONS
+    }

inventree_mcp-0.1.0/inventree_mcp/filter_introspection.py

@@ -0,0 +1,189 @@
+"""Describe a DRF list view's real filter/search/ordering options.
+
+Mirrors schema_introspection.py's approach for output shapes: rather than
+hand-maintain a description of what's filterable per resource (which would
+drift as InvenTree's FilterSet classes evolve), this reads the same metadata
+django-filter itself uses (view.filterset_class.base_filters) plus DRF's
+search_fields/ordering_fields, and turns it into a plain dict a calling
+agent can use directly as the `filters` argument on a list_* tool.
+
+Some views (e.g. company.api.ContactList/AddressList) skip a full
+filterset_class and instead use DRF's `filterset_fields = [...]` shorthand,
+which makes django_filter's DjangoFilterBackend auto-build an exact-match
+FilterSet at request time - the real API genuinely accepts these as query
+params, but there's no filterset_class for us to introspect. _model_field_filters()
+covers that case by reading the field type off the view's own model instead.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import django_filters as df
+from django.core.exceptions import FieldDoesNotExist
+
+# Best-effort Django model field internal-type -> our type string, used only
+# as a fallback for plain `filterset_fields` (no explicit FilterSet class to
+# read a real django_filters.Filter subclass off of). Not exhaustive - falls
+# back to "string" for anything unlisted, same permissive spirit as
+# _filter_type_name() below.
+_MODEL_FIELD_TYPES: dict[str, str] = {
+    "ForeignKey": "integer (id)",
+    "OneToOneField": "integer (id)",
+    "BooleanField": "boolean",
+    "IntegerField": "number",
+    "PositiveIntegerField": "number",
+    "FloatField": "number",
+    "DecimalField": "number",
+    "DateTimeField": "string (date-time)",
+    "DateField": "string (date)",
+    "TimeField": "string (time)",
+    "UUIDField": "string (uuid)",
+}
+
+# Ordered most-specific-subclass-first: e.g. ModelChoiceFilter is a
+# ChoiceFilter subclass and must be matched before the generic entry below it.
+_ORDERED_FILTER_TYPES: list[tuple[type, str]] = [
+    (df.BooleanFilter, "boolean"),
+    (df.ModelMultipleChoiceFilter, "array of integer (id)"),
+    (df.ModelChoiceFilter, "integer (id)"),
+    (df.MultipleChoiceFilter, "array of string (choice)"),
+    (df.ChoiceFilter, "string (choice)"),
+    (df.NumberFilter, "number"),
+    (df.DateTimeFilter, "string (date-time)"),
+    (df.DateFilter, "string (date)"),
+    (df.TimeFilter, "string (time)"),
+    (df.UUIDFilter, "string (uuid)"),
+    (df.CharFilter, "string"),
+]
+
+
+def _filter_type_name(f: df.Filter) -> str:
+    for filter_type, name in _ORDERED_FILTER_TYPES:
+        if isinstance(f, filter_type):
+            return name
+    return "string"
+
+
+def _filter_info(f: df.Filter) -> dict[str, Any]:
+    info: dict[str, Any] = {"type": _filter_type_name(f)}
+
+    if f.label:
+        info["label"] = str(f.label)
+
+    choices = getattr(f, "extra", {}).get("choices")
+    if choices:
+        info["choices"] = [value for value, _display in choices]
+
+    return info
+
+
+def _model_field_filters(view_cls: type) -> dict[str, Any]:
+    """Best-effort filter info for views using DRF's `filterset_fields` shorthand.
+
+    No django_filters.Filter instances exist to introspect here - only a
+    list of field names DjangoFilterBackend auto-generates exact-match
+    filters from at request time - so this reads the type straight off the
+    view's own model instead.
+    """
+    field_names = getattr(view_cls, "filterset_fields", None) or []
+    model = getattr(getattr(view_cls, "queryset", None), "model", None)
+    if not field_names or model is None:
+        return {}
+
+    filters = {}
+    for name in field_names:
+        try:
+            field = model._meta.get_field(name)
+        except FieldDoesNotExist:
+            filters[name] = {"type": "string"}
+            continue
+
+        filters[name] = {
+            "type": _MODEL_FIELD_TYPES.get(field.get_internal_type(), "string")
+        }
+
+    return filters
+
+
+def _default_ordering_fields(view_cls: type) -> list[str]:
+    """Best-effort reproduction of DRF's own fallback for views that don't declare `ordering_fields`.
+
+    `rest_framework.filters.OrderingFilter.get_default_valid_fields()` doesn't
+    treat a missing `ordering_fields` as "no ordering allowed" - it allows
+    ordering by any non-write-only field on the view's serializer instead.
+    Before this, `describe_filterset()` read `getattr(view_cls,
+    'ordering_fields', None) or []`, which couldn't distinguish "not declared"
+    from "declared empty" and reported zero ordering fields either way - e.g.
+    `describe_filters("bom_substitute")` claimed no ordering was possible even
+    though `ordering=part` genuinely works against the real API
+    (`BomItemSubstituteList` doesn't declare `ordering_fields`). Mirrors DRF's
+    logic rather than calling it directly: DRF's version needs a bound view
+    *instance* (`view.get_serializer_class()`), but this module only ever has
+    the view *class* to introspect with, same constraint as the rest of this
+    file.
+    """
+    serializer_class = getattr(view_cls, "serializer_class", None)
+    if serializer_class is None:
+        return []
+
+    try:
+        fields = serializer_class().fields
+    except (TypeError, AssertionError):
+        # TypeError: constructor needs args this bare instantiation can't
+        # supply. AssertionError: DRF's own internal checks (e.g. a
+        # ModelSerializer subclass missing Meta.model). Fail soft to "no
+        # ordering fields reported" rather than raising out of a pure
+        # introspection helper.
+        return []
+
+    ordering_fields: list[str] = []
+    for field in fields.values():
+        if getattr(field, "write_only", False) or field.source == "*":
+            continue
+        source = field.source.replace(".", "__")
+        if source not in ordering_fields:
+            ordering_fields.append(source)
+
+    return ordering_fields
+
+
+def describe_filterset(view_cls: type) -> dict[str, Any]:
+    """Describe the search/filter/ordering options available on *view_cls*.
+
+    Args:
+        view_cls: a list view class as used in the real API urlconf (e.g.
+            part.api.PartList).
+
+    Returns:
+        A dict with:
+        - search_fields: fields matched by a free-text `search` query param.
+        - ordering_fields: fields usable as the corresponding list tool's
+          `ordering` argument (prefix with '-' for descending). If the view
+          doesn't declare `ordering_fields` at all, this reports DRF's own
+          fallback (any readable serializer field) rather than an empty list
+          - see _default_ordering_fields().
+        - filters: {name: {type, label, choices}} - each key is usable
+          directly as a query parameter / filters dict entry.
+    """
+    filterset_class = getattr(view_cls, "filterset_class", None)
+
+    if filterset_class is not None:
+        filters = {
+            name: _filter_info(f) for name, f in filterset_class.base_filters.items()
+        }
+    else:
+        filters = _model_field_filters(view_cls)
+
+    declared_ordering = getattr(view_cls, "ordering_fields", None)
+    ordering_fields = (
+        list(declared_ordering)
+        if declared_ordering is not None
+        else _default_ordering_fields(view_cls)
+    )
+
+    return {
+        "search_fields": list(getattr(view_cls, "search_fields", None) or []),
+        "ordering_fields": ordering_fields,
+        "filters": filters,
+    }