indox-mcp 0.7.0__tar.gz

indox_mcp-0.7.0/LICENSE

@@ -0,0 +1,67 @@
+Copyright (c) 2026 Indox. All rights reserved.
+
+PROPRIETARY LICENSE
+
+This software (the "SDK") comprises the official client libraries for the Indox
+API. It is made publicly readable so that developers can inspect, evaluate and
+integrate against the Indox service. It is not open-source software.
+
+GRANT
+
+Subject to the terms below, Indox grants you a non-exclusive, non-transferable,
+non-sublicensable, revocable, royalty-free licence to:
+
+  1. install and copy the SDK ONLY to the extent technically necessary to run it
+     within your own application, and ONLY for the purpose of calling the Indox
+     API under a valid Indox account;
+  2. modify the SDK ONLY as required to integrate it with that application; and
+  3. distribute the SDK, modified or unmodified, ONLY as a non-primary embedded
+     component of such an application, with this notice retained in full.
+
+No other right is granted. Any use not expressly permitted above is reserved.
+
+RESTRICTIONS
+
+You may not, in whole or in part:
+
+  1. copy, publish, mirror, host or redistribute the SDK or its source as a
+     standalone work, under any name, on any package registry, repository or
+     distribution channel;
+  2. create, publish or distribute a derivative SDK, client library, wrapper,
+     port or translation of the SDK into any other language;
+  3. use the SDK, or knowledge derived from it, to build, operate, market or
+     assist any product or service that competes with Indox;
+  4. use the SDK or its source as input to train, fine-tune, evaluate or ground
+     any machine-learning model, or include it in any dataset for that purpose;
+  5. reverse engineer, decompile or study the SDK to replicate, reimplement or
+     circumvent the Indox API or any part of the Indox service;
+  6. use the SDK to access the Indox API without a valid account and API key, or
+     to exceed, evade or disguise the limits of your plan;
+  7. sell, lease, sublicense, rent or otherwise transfer the SDK or any right in
+     it to a third party;
+  8. remove, obscure or alter any copyright, trademark or licence notice; or
+  9. use the Indox name, logo or trademarks except to state factually that your
+     application integrates with the Indox API.
+
+Where mandatory law grants you a right that this licence purports to restrict,
+that restriction does not apply to you to the minimum extent required by law.
+
+Use of the Indox API itself is governed separately by the Indox Terms of Service
+and requires a valid account and API key. This licence covers the SDK source
+only and grants no right to the service.
+
+NO WARRANTY
+
+THE SDK 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 INDOX 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 SDK OR THE USE OR
+OTHER DEALINGS IN THE SDK.
+
+TERMINATION
+
+This licence terminates automatically if you breach it. On termination you must
+cease all use and destroy all copies of the SDK.
+
+Questions: support@indox.org

indox_mcp-0.7.0/PKG-INFO

@@ -0,0 +1,200 @@
+Metadata-Version: 2.4
+Name: indox-mcp
+Version: 0.7.0
+Summary: MCP server for the Indox document and media conversion API.
+Author-email: Indox <support@indox.org>
+License-Expression: LicenseRef-Proprietary
+Keywords: indox,mcp,model-context-protocol,document-conversion
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: indox-client==0.7.0
+Requires-Dist: mcp<3,>=2.3
+Requires-Dist: uvicorn>=0.31
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: responses>=0.23.0; extra == "test"
+Requires-Dist: ruff==0.17.3; extra == "test"
+Dynamic: license-file
+
+# indox-mcp
+
+<!-- mcp-name: org.indox/indox-mcp -->
+
+MCP server for the [Indox](https://indox.org) conversion API. It lets an AI client — Claude Code,
+Claude Desktop, Cursor, VS Code — convert documents, images, video, 3D models and fonts, check
+credits, manage stored files and webhooks, and ask questions about PDFs. Every tool is a thin
+wrapper over the official Python SDK, [`indox-client`](https://pypi.org/project/indox-client/).
+
+**Requires:** Python ≥ 3.11 · an Indox API key (`ak_…`, created in the dashboard under **API Keys**)
+
+It runs two ways from the same tools:
+
+| Mode | Run | Auth | Files |
+|---|---|---|---|
+| Local | `indox-mcp` (stdio) | `INDOX_API_KEY` in the server's environment | read and written inside `INDOX_MCP_WORKSPACE_DIR` only |
+| Hosted | `https://mcp.indox.org/mcp` (Streamable HTTP) | `Authorization: Bearer <your API key>` | `file_url` or `s3_key` in, `download_url` out |
+
+## Tools
+
+| Tool | What it does | Mode |
+|---|---|---|
+| `health` | Check that the Indox API is reachable | both |
+| `credits_balance` | Remaining credits — check before large batches | both |
+| `usage_summary` | Recent conversion usage | both |
+| `list_formats` | Input and output formats for a kind: `image`, `video`, `model`, `pdf`, `font` | both |
+| `convert_file` | Start a conversion from one source: `file_path`, `file_url` or `s3_key`. Spends credits | both (`file_path` local only) |
+| `get_conversion` | Current status of a conversion | both |
+| `wait_conversion` | Poll until it finishes or the time limit passes (`finished=false` → call again) | both |
+| `download_result` | Local: save the result into the workspace, never overwriting. Hosted: return its link | both |
+| `list_files` | Files in your Indox storage | both |
+| `create_upload_url` | A presigned upload URL; pass the returned `s3_key` to `convert_file` | both |
+| `list_webhooks` · `create_webhook` · `test_webhook` · `delete_webhook` | Manage webhooks. The signing secret is never returned to the model | both |
+| `pdf_form_fields` | List the fillable fields of a local PDF | local |
+| `pdf_ai_ask` | Ask a question about a local PDF. Spends credits | local |
+| `pdf_ai_job` | Status and answer of a `pdf_ai_ask` job | both |
+
+Tools that spend credits or change data are marked as not read-only, so clients can ask before
+running them. Text extracted from your documents is treated as data, never as instructions.
+
+## Local mode (stdio)
+
+```bash
+pip install indox-mcp
+```
+
+The server starts only when every variable below is set, and names the first one missing.
+
+| Variable | Value |
+|---|---|
+| `INDOX_API_KEY` | your `ak_…` key |
+| `INDOX_BASE_URL` | `https://indox.org` |
+| `INDOX_MCP_WORKSPACE_DIR` | absolute path of the folder the server may read from and save results to |
+| `INDOX_MCP_WAIT_MAX_SECONDS` | longest one `wait_conversion` call may poll, e.g. `120` |
+| `INDOX_MCP_POLL_SECONDS` | seconds between status checks, e.g. `2` |
+
+If a client cannot find `indox-mcp`, use the full path that `which indox-mcp` prints.
+
+## Hosted mode
+
+The hosted server is **not live yet**; it will be at `https://mcp.indox.org/mcp`. Send your API key
+as `Authorization: Bearer ak_…`; each call runs with that key alone.
+
+**Downloads:** a hosted `download_result` returns a link with `needs_api_key=true` — fetch it with
+the same API key. Key-free signed links are planned; until they ship, hosted downloads need the
+caller's key.
+
+## Client setup
+
+Replace `ak_your_key` and `/absolute/path/to/files` with your own values.
+
+**Claude Code** — local, then hosted:
+
+```bash
+claude mcp add --env INDOX_API_KEY=ak_your_key --env INDOX_BASE_URL=https://indox.org \
+  --env INDOX_MCP_WORKSPACE_DIR=/absolute/path/to/files \
+  --env INDOX_MCP_WAIT_MAX_SECONDS=120 --env INDOX_MCP_POLL_SECONDS=2 \
+  --transport stdio indox -- indox-mcp
+
+claude mcp add --transport http indox-hosted https://mcp.indox.org/mcp \
+  --header "Authorization: Bearer ak_your_key"
+```
+
+Add `--scope project` to share the server through `.mcp.json`, or `--scope user` for every project.
+
+**Claude Desktop** — Settings › Developer › Edit Config opens `claude_desktop_config.json`
+(macOS `~/Library/Application Support/Claude/`, Windows `%APPDATA%\Claude\`):
+
+```json
+{
+  "mcpServers": {
+    "indox": {
+      "command": "indox-mcp",
+      "env": {
+        "INDOX_API_KEY": "ak_your_key",
+        "INDOX_BASE_URL": "https://indox.org",
+        "INDOX_MCP_WORKSPACE_DIR": "/absolute/path/to/files",
+        "INDOX_MCP_WAIT_MAX_SECONDS": "120",
+        "INDOX_MCP_POLL_SECONDS": "2"
+      }
+    }
+  }
+}
+```
+
+The hosted server is added as a custom connector (Customize › Connectors › Add custom connector),
+not in this file. An API key goes under **Request headers** as `Bearer ak_your_key`; that option is
+in beta, and on Team and Enterprise plans every member would share one key — use local mode there.
+
+**Cursor** — `.cursor/mcp.json` in a project, or `~/.cursor/mcp.json` for every project:
+
+```json
+{
+  "mcpServers": {
+    "indox": {
+      "type": "stdio",
+      "command": "indox-mcp",
+      "env": {
+        "INDOX_API_KEY": "${env:INDOX_API_KEY}",
+        "INDOX_BASE_URL": "https://indox.org",
+        "INDOX_MCP_WORKSPACE_DIR": "/absolute/path/to/files",
+        "INDOX_MCP_WAIT_MAX_SECONDS": "120",
+        "INDOX_MCP_POLL_SECONDS": "2"
+      }
+    },
+    "indox-hosted": {
+      "url": "https://mcp.indox.org/mcp",
+      "headers": { "Authorization": "Bearer ${env:INDOX_API_KEY}" }
+    }
+  }
+}
+```
+
+**VS Code** (Copilot agent mode) — `.vscode/mcp.json`; VS Code prompts for the key and hides what you type:
+
+```json
+{
+  "inputs": [
+    { "type": "promptString", "id": "indox-key", "description": "Indox API key", "password": true }
+  ],
+  "servers": {
+    "indox": {
+      "type": "stdio",
+      "command": "indox-mcp",
+      "env": {
+        "INDOX_API_KEY": "${input:indox-key}",
+        "INDOX_BASE_URL": "https://indox.org",
+        "INDOX_MCP_WORKSPACE_DIR": "/absolute/path/to/files",
+        "INDOX_MCP_WAIT_MAX_SECONDS": "120",
+        "INDOX_MCP_POLL_SECONDS": "2"
+      }
+    },
+    "indox-hosted": {
+      "type": "http",
+      "url": "https://mcp.indox.org/mcp",
+      "headers": { "Authorization": "Bearer ${input:indox-key}" }
+    }
+  }
+}
+```
+
+## Run the HTTP server yourself
+
+`indox-mcp --http` serves Streamable HTTP at `/mcp` and an open `/healthz`. Each request uses the
+caller's own key; the server holds no key of its own. Required variables:
+
+| Variable | Value |
+|---|---|
+| `INDOX_BASE_URL` | `https://indox.org` |
+| `MCP_HOST` · `MCP_PORT` | bind address and port |
+| `MCP_ALLOWED_HOSTS` | comma-separated `Host` values to accept, e.g. `mcp.example.com` |
+| `MCP_ALLOWED_ORIGINS` | comma-separated browser origins to accept |
+| `MCP_KEY_CACHE_SECONDS` · `MCP_KEY_CACHE_SIZE` | how long, and how many, verified keys are remembered (hashed, in memory) |
+| `INDOX_MCP_WAIT_MAX_SECONDS` · `INDOX_MCP_POLL_SECONDS` | as in local mode; keep the wait low when hosted |
+
+Client config formats checked on 2026-10-29 against
+[Claude Code](https://code.claude.com/docs/en/mcp),
+[Claude Desktop](https://modelcontextprotocol.io/docs/develop/connect-local-servers) and
+[custom connectors](https://claude.com/docs/connectors/custom/remote-mcp),
+[Cursor](https://cursor.com/docs/context/mcp) and
+[VS Code](https://code.visualstudio.com/docs/copilot/reference/mcp-configuration).

indox_mcp-0.7.0/README.md

@@ -0,0 +1,181 @@
+# indox-mcp
+
+<!-- mcp-name: org.indox/indox-mcp -->
+
+MCP server for the [Indox](https://indox.org) conversion API. It lets an AI client — Claude Code,
+Claude Desktop, Cursor, VS Code — convert documents, images, video, 3D models and fonts, check
+credits, manage stored files and webhooks, and ask questions about PDFs. Every tool is a thin
+wrapper over the official Python SDK, [`indox-client`](https://pypi.org/project/indox-client/).
+
+**Requires:** Python ≥ 3.11 · an Indox API key (`ak_…`, created in the dashboard under **API Keys**)
+
+It runs two ways from the same tools:
+
+| Mode | Run | Auth | Files |
+|---|---|---|---|
+| Local | `indox-mcp` (stdio) | `INDOX_API_KEY` in the server's environment | read and written inside `INDOX_MCP_WORKSPACE_DIR` only |
+| Hosted | `https://mcp.indox.org/mcp` (Streamable HTTP) | `Authorization: Bearer <your API key>` | `file_url` or `s3_key` in, `download_url` out |
+
+## Tools
+
+| Tool | What it does | Mode |
+|---|---|---|
+| `health` | Check that the Indox API is reachable | both |
+| `credits_balance` | Remaining credits — check before large batches | both |
+| `usage_summary` | Recent conversion usage | both |
+| `list_formats` | Input and output formats for a kind: `image`, `video`, `model`, `pdf`, `font` | both |
+| `convert_file` | Start a conversion from one source: `file_path`, `file_url` or `s3_key`. Spends credits | both (`file_path` local only) |
+| `get_conversion` | Current status of a conversion | both |
+| `wait_conversion` | Poll until it finishes or the time limit passes (`finished=false` → call again) | both |
+| `download_result` | Local: save the result into the workspace, never overwriting. Hosted: return its link | both |
+| `list_files` | Files in your Indox storage | both |
+| `create_upload_url` | A presigned upload URL; pass the returned `s3_key` to `convert_file` | both |
+| `list_webhooks` · `create_webhook` · `test_webhook` · `delete_webhook` | Manage webhooks. The signing secret is never returned to the model | both |
+| `pdf_form_fields` | List the fillable fields of a local PDF | local |
+| `pdf_ai_ask` | Ask a question about a local PDF. Spends credits | local |
+| `pdf_ai_job` | Status and answer of a `pdf_ai_ask` job | both |
+
+Tools that spend credits or change data are marked as not read-only, so clients can ask before
+running them. Text extracted from your documents is treated as data, never as instructions.
+
+## Local mode (stdio)
+
+```bash
+pip install indox-mcp
+```
+
+The server starts only when every variable below is set, and names the first one missing.
+
+| Variable | Value |
+|---|---|
+| `INDOX_API_KEY` | your `ak_…` key |
+| `INDOX_BASE_URL` | `https://indox.org` |
+| `INDOX_MCP_WORKSPACE_DIR` | absolute path of the folder the server may read from and save results to |
+| `INDOX_MCP_WAIT_MAX_SECONDS` | longest one `wait_conversion` call may poll, e.g. `120` |
+| `INDOX_MCP_POLL_SECONDS` | seconds between status checks, e.g. `2` |
+
+If a client cannot find `indox-mcp`, use the full path that `which indox-mcp` prints.
+
+## Hosted mode
+
+The hosted server is **not live yet**; it will be at `https://mcp.indox.org/mcp`. Send your API key
+as `Authorization: Bearer ak_…`; each call runs with that key alone.
+
+**Downloads:** a hosted `download_result` returns a link with `needs_api_key=true` — fetch it with
+the same API key. Key-free signed links are planned; until they ship, hosted downloads need the
+caller's key.
+
+## Client setup
+
+Replace `ak_your_key` and `/absolute/path/to/files` with your own values.
+
+**Claude Code** — local, then hosted:
+
+```bash
+claude mcp add --env INDOX_API_KEY=ak_your_key --env INDOX_BASE_URL=https://indox.org \
+  --env INDOX_MCP_WORKSPACE_DIR=/absolute/path/to/files \
+  --env INDOX_MCP_WAIT_MAX_SECONDS=120 --env INDOX_MCP_POLL_SECONDS=2 \
+  --transport stdio indox -- indox-mcp
+
+claude mcp add --transport http indox-hosted https://mcp.indox.org/mcp \
+  --header "Authorization: Bearer ak_your_key"
+```
+
+Add `--scope project` to share the server through `.mcp.json`, or `--scope user` for every project.
+
+**Claude Desktop** — Settings › Developer › Edit Config opens `claude_desktop_config.json`
+(macOS `~/Library/Application Support/Claude/`, Windows `%APPDATA%\Claude\`):
+
+```json
+{
+  "mcpServers": {
+    "indox": {
+      "command": "indox-mcp",
+      "env": {
+        "INDOX_API_KEY": "ak_your_key",
+        "INDOX_BASE_URL": "https://indox.org",
+        "INDOX_MCP_WORKSPACE_DIR": "/absolute/path/to/files",
+        "INDOX_MCP_WAIT_MAX_SECONDS": "120",
+        "INDOX_MCP_POLL_SECONDS": "2"
+      }
+    }
+  }
+}
+```
+
+The hosted server is added as a custom connector (Customize › Connectors › Add custom connector),
+not in this file. An API key goes under **Request headers** as `Bearer ak_your_key`; that option is
+in beta, and on Team and Enterprise plans every member would share one key — use local mode there.
+
+**Cursor** — `.cursor/mcp.json` in a project, or `~/.cursor/mcp.json` for every project:
+
+```json
+{
+  "mcpServers": {
+    "indox": {
+      "type": "stdio",
+      "command": "indox-mcp",
+      "env": {
+        "INDOX_API_KEY": "${env:INDOX_API_KEY}",
+        "INDOX_BASE_URL": "https://indox.org",
+        "INDOX_MCP_WORKSPACE_DIR": "/absolute/path/to/files",
+        "INDOX_MCP_WAIT_MAX_SECONDS": "120",
+        "INDOX_MCP_POLL_SECONDS": "2"
+      }
+    },
+    "indox-hosted": {
+      "url": "https://mcp.indox.org/mcp",
+      "headers": { "Authorization": "Bearer ${env:INDOX_API_KEY}" }
+    }
+  }
+}
+```
+
+**VS Code** (Copilot agent mode) — `.vscode/mcp.json`; VS Code prompts for the key and hides what you type:
+
+```json
+{
+  "inputs": [
+    { "type": "promptString", "id": "indox-key", "description": "Indox API key", "password": true }
+  ],
+  "servers": {
+    "indox": {
+      "type": "stdio",
+      "command": "indox-mcp",
+      "env": {
+        "INDOX_API_KEY": "${input:indox-key}",
+        "INDOX_BASE_URL": "https://indox.org",
+        "INDOX_MCP_WORKSPACE_DIR": "/absolute/path/to/files",
+        "INDOX_MCP_WAIT_MAX_SECONDS": "120",
+        "INDOX_MCP_POLL_SECONDS": "2"
+      }
+    },
+    "indox-hosted": {
+      "type": "http",
+      "url": "https://mcp.indox.org/mcp",
+      "headers": { "Authorization": "Bearer ${input:indox-key}" }
+    }
+  }
+}
+```
+
+## Run the HTTP server yourself
+
+`indox-mcp --http` serves Streamable HTTP at `/mcp` and an open `/healthz`. Each request uses the
+caller's own key; the server holds no key of its own. Required variables:
+
+| Variable | Value |
+|---|---|
+| `INDOX_BASE_URL` | `https://indox.org` |
+| `MCP_HOST` · `MCP_PORT` | bind address and port |
+| `MCP_ALLOWED_HOSTS` | comma-separated `Host` values to accept, e.g. `mcp.example.com` |
+| `MCP_ALLOWED_ORIGINS` | comma-separated browser origins to accept |
+| `MCP_KEY_CACHE_SECONDS` · `MCP_KEY_CACHE_SIZE` | how long, and how many, verified keys are remembered (hashed, in memory) |
+| `INDOX_MCP_WAIT_MAX_SECONDS` · `INDOX_MCP_POLL_SECONDS` | as in local mode; keep the wait low when hosted |
+
+Client config formats checked on 2026-10-29 against
+[Claude Code](https://code.claude.com/docs/en/mcp),
+[Claude Desktop](https://modelcontextprotocol.io/docs/develop/connect-local-servers) and
+[custom connectors](https://claude.com/docs/connectors/custom/remote-mcp),
+[Cursor](https://cursor.com/docs/context/mcp) and
+[VS Code](https://code.visualstudio.com/docs/copilot/reference/mcp-configuration).

indox_mcp-0.7.0/indox_mcp/__init__.py

@@ -0,0 +1,3 @@
+from ._version import __version__
+
+__all__ = ["__version__"]

indox_mcp-0.7.0/indox_mcp/_version.py

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

indox_mcp-0.7.0/indox_mcp/auth.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import hashlib
+import logging
+import time
+from collections import OrderedDict
+from enum import Enum
+
+import anyio
+from indox_client import AuthenticationError, Indox, IndoxError, PermissionDeniedError
+from mcp.server.auth.provider import AccessToken
+
+log = logging.getLogger(__name__)
+
+
+class Probe(Enum):
+    VALID = "valid"
+    INVALID = "invalid"
+    UNKNOWN = "unknown"
+
+
+class ApiKeyVerifier:
+    def __init__(self, base_url: str, *, ttl_seconds: float, max_entries: int) -> None:
+        self._base_url = base_url
+        self._ttl = ttl_seconds
+        self._max = max_entries
+        self._accepted_until: OrderedDict[str, float] = OrderedDict()
+
+    async def verify_token(self, token: str) -> AccessToken | None:
+        digest = hashlib.sha256(token.encode()).hexdigest()
+        now = time.monotonic()
+        if self._accepted_until.get(digest, 0.0) > now:
+            self._accepted_until.move_to_end(digest)
+        else:
+            self._accepted_until.pop(digest, None)
+            probe = await anyio.to_thread.run_sync(self._probe, token)
+            if probe is Probe.INVALID:
+                return None
+            if probe is Probe.VALID:
+                self._remember(digest, now + self._ttl)
+        return AccessToken(token=token, client_id=f"api-key:{digest[:16]}", scopes=[])
+
+    def _remember(self, digest: str, until: float) -> None:
+        self._accepted_until[digest] = until
+        while len(self._accepted_until) > self._max:
+            self._accepted_until.popitem(last=False)
+
+    def _probe(self, token: str) -> Probe:
+        with Indox(api_key=token, base_url=self._base_url, max_retries=0) as client:
+            try:
+                client.billing.credits_balance()
+            except AuthenticationError:
+                return Probe.INVALID
+            except PermissionDeniedError:
+                return Probe.VALID
+            except IndoxError as exc:
+                log.warning("API key check unavailable, deferring to the API: %s", type(exc).__name__)
+                return Probe.UNKNOWN
+        return Probe.VALID

indox_mcp-0.7.0/indox_mcp/catalog.py

@@ -0,0 +1,44 @@
+_MEDIA_GET = "GET /api/v1/media_core/conversion/{conversion_id}/"
+_PDF_GET = "GET /api/v1/pdf_handler/conversion/{conversion_id}/"
+_FONT_GET = "GET /api/v1/fonts/conversion/{conversion_id}/"
+_STATUS = (_MEDIA_GET, _PDF_GET, _FONT_GET)
+
+OPS: dict[str, tuple[str, ...]] = {
+    "health": ("GET /api/v1/health/",),
+    "credits_balance": ("GET /api/v1/subscription/credits/balance/",),
+    "usage_summary": ("GET /api/v1/user/usage/summary/",),
+    "list_formats": (
+        "GET /api/v1/convert/image/formats/",
+        "GET /api/v1/convert/video/formats/",
+        "GET /api/v1/convert/model/formats/",
+        "GET /api/v1/pdf_handler/formats/",
+        "GET /api/v1/fonts/formats/",
+    ),
+    "convert_file": (
+        "POST /api/v1/convert/image/convert/",
+        "POST /api/v1/convert/video/convert/",
+        "POST /api/v1/convert/model/convert/",
+        "POST /api/v1/pdf_handler/convert/",
+        "POST /api/v1/fonts/upload/",
+        "POST /api/v1/fonts/convert/",
+    ),
+    "get_conversion": _STATUS,
+    "wait_conversion": _STATUS,
+    "download_result": (
+        *_STATUS,
+        "GET /api/v1/media_core/files/{conversion_id}/download/",
+        "GET /api/v1/pdf_handler/{conversion_id}/download/",
+        "GET /api/v1/fonts/{conversion_id}/download/{filename}",
+    ),
+    "list_files": ("GET /api/v1/user/storage/files/",),
+    "create_upload_url": ("POST /api/v1/user/storage/files/presign/",),
+    "list_webhooks": ("GET /api/v1/webhooks/",),
+    "create_webhook": ("POST /api/v1/webhooks/",),
+    "test_webhook": ("POST /api/v1/webhooks/{webhook_id}/test/",),
+    "delete_webhook": ("DELETE /api/v1/webhooks/{webhook_id}/",),
+    "pdf_form_fields": ("POST /api/v1/pdf_handler/form-fields/",),
+    "pdf_ai_ask": ("POST /api/v1/pdf_handler/ai/ask/",),
+    "pdf_ai_job": ("GET /api/v1/pdf_handler/ai/jobs/{job_id}/",),
+}
+
+LOCAL_ONLY = frozenset({"pdf_form_fields", "pdf_ai_ask"})

indox_mcp-0.7.0/indox_mcp/cli.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+
+from ._version import __version__
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="indox-mcp",
+        description="Indox MCP server. Runs over stdio unless --http is given.",
+    )
+    parser.add_argument("--http", action="store_true", help="serve Streamable HTTP (hosted mode)")
+    parser.add_argument("--version", action="version", version=f"indox-mcp {__version__}")
+    args = parser.parse_args(argv)
+    if args.http:
+        from .config import hosted_config
+        from .hosted import serve
+
+        serve(hosted_config())
+        return
+    from .config import local_config
+    from .runtime import Runtime
+    from .server import build
+
+    cfg = local_config()
+    rt = Runtime(
+        base_url=cfg.base_url,
+        wait_max_seconds=cfg.wait_max_seconds,
+        poll_seconds=cfg.poll_seconds,
+        workspace=cfg.workspace,
+        api_key=cfg.api_key,
+    )
+    build(rt).run("stdio")

indox_mcp-0.7.0/indox_mcp/config.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+def require(name: str) -> str:
+    value = os.environ.get(name, "").strip()
+    if not value:
+        raise SystemExit(f"{name} missing from the environment")
+    return value
+
+
+def _number(name: str) -> float:
+    raw = require(name)
+    try:
+        value = float(raw)
+    except ValueError:
+        raise SystemExit(f"{name} must be a number, got {raw!r}") from None
+    if value <= 0:
+        raise SystemExit(f"{name} must be positive, got {raw!r}")
+    return value
+
+
+def _list(name: str) -> list[str]:
+    return [item.strip() for item in require(name).split(",") if item.strip()]
+
+
+@dataclass(frozen=True)
+class LocalConfig:
+    api_key: str
+    base_url: str
+    workspace: Path
+    wait_max_seconds: float
+    poll_seconds: float
+
+
+@dataclass(frozen=True)
+class HostedConfig:
+    base_url: str
+    host: str
+    port: int
+    allowed_hosts: list[str]
+    allowed_origins: list[str]
+    key_cache_seconds: float
+    key_cache_size: int
+    wait_max_seconds: float
+    poll_seconds: float
+
+
+def local_config() -> LocalConfig:
+    workspace = Path(require("INDOX_MCP_WORKSPACE_DIR")).expanduser().resolve()
+    if not workspace.is_dir():
+        raise SystemExit(f"INDOX_MCP_WORKSPACE_DIR is not a directory: {workspace}")
+    return LocalConfig(
+        api_key=require("INDOX_API_KEY"),
+        base_url=require("INDOX_BASE_URL"),
+        workspace=workspace,
+        wait_max_seconds=_number("INDOX_MCP_WAIT_MAX_SECONDS"),
+        poll_seconds=_number("INDOX_MCP_POLL_SECONDS"),
+    )
+
+
+def hosted_config() -> HostedConfig:
+    return HostedConfig(
+        base_url=require("INDOX_BASE_URL"),
+        host=require("MCP_HOST"),
+        port=int(_number("MCP_PORT")),
+        allowed_hosts=_list("MCP_ALLOWED_HOSTS"),
+        allowed_origins=_list("MCP_ALLOWED_ORIGINS"),
+        key_cache_seconds=_number("MCP_KEY_CACHE_SECONDS"),
+        key_cache_size=int(_number("MCP_KEY_CACHE_SIZE")),
+        wait_max_seconds=_number("INDOX_MCP_WAIT_MAX_SECONDS"),
+        poll_seconds=_number("INDOX_MCP_POLL_SECONDS"),
+    )