convertfilefast-mcp 0.1.0__tar.gz

convertfilefast_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: convertfilefast-mcp
+Version: 0.1.0
+Summary: MCP server for ConvertFileFast — convert 50+ file formats and run PDF/image operations as AI-agent tools.
+Author: ConvertFileFast
+License: MIT
+Keywords: mcp,model-context-protocol,pdf,file-conversion,convert,agents
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastmcp>=3.0
+Requires-Dist: httpx>=0.27
+
+# ConvertFileFast MCP server
+
+An [MCP](https://modelcontextprotocol.io) server that lets AI agents (Claude
+Desktop, Claude Code, Cursor, etc.) convert files and run PDF/image operations
+through the ConvertFileFast API.
+
+It is a **separate service** that talks to the ConvertFileFast REST API over
+HTTP — it does not import the backend, so it never affects the API's
+dependencies, and it mirrors how the hosted MCP runs in production.
+
+## Tools
+
+| Tool | What it does |
+|------|--------------|
+| `convert_file` | Convert between 40+ format pairs (DOCX→PDF, PDF→CSV, PDF→JPG, HTML→PDF, URL→PDF, PNG→JPG, CSV→JSON, …) |
+| `merge_pdfs` | Merge multiple PDFs into one |
+| `split_pdf` | Extract pages/ranges from a PDF |
+| `compress_pdf` | Reduce PDF size (low/medium/high/maximum) |
+| `rotate_pdf` | Rotate pages (90/180/270°) |
+| `protect_pdf` | Add password protection |
+| `unlock_pdf` | Remove password protection |
+| `resize_image` | Resize an image |
+| `compress_image` | Compress an image (and optionally cap dimensions) |
+
+Every tool accepts a public `source_url` (preferred — the agent passes a URL and
+never handles binary) **or** `file_base64`. The result file is written to the
+output directory and the tool returns its path.
+
+## Prerequisites
+
+A ConvertFileFast API key (starts with `cff_`). Create one at
+<https://www.convertfilefast.com/signup>.
+
+## Configuration
+
+The server reads these environment variables:
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `CONVERTFILEFAST_API_KEY` | — | Your `cff_` key (sent as `X-API-Key`) |
+| `CONVERTFILEFAST_API_BASE` | `https://api.convertfilefast.com` | API base URL (set to `http://127.0.0.1:8000` to test against a local backend) |
+| `CONVERTFILEFAST_OUTPUT_DIR` | `~/ConvertFileFast` | Where converted files are saved |
+| `CONVERTFILEFAST_TIMEOUT` | `180` | Per-request timeout (seconds) |
+
+## Install (local, works today)
+
+Until the package is published to PyPI, point your MCP client at the local
+virtual environment created for this repo.
+
+### Claude Desktop
+
+Edit `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "convertfilefast": {
+      "command": "C:\\Projetos\\GitHub-Clones\\conversor-pdf\\mcp\\.venv\\Scripts\\python.exe",
+      "args": ["C:\\Projetos\\GitHub-Clones\\conversor-pdf\\mcp\\server.py"],
+      "env": {
+        "CONVERTFILEFAST_API_KEY": "cff_REPLACE_WITH_YOUR_KEY"
+      }
+    }
+  }
+}
+```
+
+Restart Claude Desktop, then ask: *"Convert https://example.com/report.docx to PDF."*
+
+### Cursor
+
+Add the same block to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (per
+project).
+
+### Claude Code
+
+```bash
+claude mcp add convertfilefast \
+  --env CONVERTFILEFAST_API_KEY=cff_REPLACE_WITH_YOUR_KEY \
+  -- "C:\Projetos\GitHub-Clones\conversor-pdf\mcp\.venv\Scripts\python.exe" \
+     "C:\Projetos\GitHub-Clones\conversor-pdf\mcp\server.py"
+```
+
+> **Testing against the local backend:** add
+> `"CONVERTFILEFAST_API_BASE": "http://127.0.0.1:8000"` to the `env` block and
+> start the backend first (`uvicorn app.main:app` from `api/`).
+
+## Future: published install
+
+Once published to PyPI, the portable, machine-independent config will be:
+
+```json
+{
+  "mcpServers": {
+    "convertfilefast": {
+      "command": "uvx",
+      "args": ["convertfilefast-mcp"],
+      "env": { "CONVERTFILEFAST_API_KEY": "cff_..." }
+    }
+  }
+}
+```
+
+## Development
+
+```bash
+# from this directory
+uv venv .venv --python 3.12
+uv pip install --python .venv/Scripts/python.exe fastmcp httpx
+
+# run (stdio)
+CONVERTFILEFAST_API_KEY=cff_... .venv/Scripts/python.exe server.py
+```
+
+Inspect the tools with the MCP Inspector:
+
+```bash
+npx @modelcontextprotocol/inspector .venv/Scripts/python.exe server.py
+```

convertfilefast_mcp-0.1.0/README.md

@@ -0,0 +1,119 @@
+# ConvertFileFast MCP server
+
+An [MCP](https://modelcontextprotocol.io) server that lets AI agents (Claude
+Desktop, Claude Code, Cursor, etc.) convert files and run PDF/image operations
+through the ConvertFileFast API.
+
+It is a **separate service** that talks to the ConvertFileFast REST API over
+HTTP — it does not import the backend, so it never affects the API's
+dependencies, and it mirrors how the hosted MCP runs in production.
+
+## Tools
+
+| Tool | What it does |
+|------|--------------|
+| `convert_file` | Convert between 40+ format pairs (DOCX→PDF, PDF→CSV, PDF→JPG, HTML→PDF, URL→PDF, PNG→JPG, CSV→JSON, …) |
+| `merge_pdfs` | Merge multiple PDFs into one |
+| `split_pdf` | Extract pages/ranges from a PDF |
+| `compress_pdf` | Reduce PDF size (low/medium/high/maximum) |
+| `rotate_pdf` | Rotate pages (90/180/270°) |
+| `protect_pdf` | Add password protection |
+| `unlock_pdf` | Remove password protection |
+| `resize_image` | Resize an image |
+| `compress_image` | Compress an image (and optionally cap dimensions) |
+
+Every tool accepts a public `source_url` (preferred — the agent passes a URL and
+never handles binary) **or** `file_base64`. The result file is written to the
+output directory and the tool returns its path.
+
+## Prerequisites
+
+A ConvertFileFast API key (starts with `cff_`). Create one at
+<https://www.convertfilefast.com/signup>.
+
+## Configuration
+
+The server reads these environment variables:
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `CONVERTFILEFAST_API_KEY` | — | Your `cff_` key (sent as `X-API-Key`) |
+| `CONVERTFILEFAST_API_BASE` | `https://api.convertfilefast.com` | API base URL (set to `http://127.0.0.1:8000` to test against a local backend) |
+| `CONVERTFILEFAST_OUTPUT_DIR` | `~/ConvertFileFast` | Where converted files are saved |
+| `CONVERTFILEFAST_TIMEOUT` | `180` | Per-request timeout (seconds) |
+
+## Install (local, works today)
+
+Until the package is published to PyPI, point your MCP client at the local
+virtual environment created for this repo.
+
+### Claude Desktop
+
+Edit `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "convertfilefast": {
+      "command": "C:\\Projetos\\GitHub-Clones\\conversor-pdf\\mcp\\.venv\\Scripts\\python.exe",
+      "args": ["C:\\Projetos\\GitHub-Clones\\conversor-pdf\\mcp\\server.py"],
+      "env": {
+        "CONVERTFILEFAST_API_KEY": "cff_REPLACE_WITH_YOUR_KEY"
+      }
+    }
+  }
+}
+```
+
+Restart Claude Desktop, then ask: *"Convert https://example.com/report.docx to PDF."*
+
+### Cursor
+
+Add the same block to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (per
+project).
+
+### Claude Code
+
+```bash
+claude mcp add convertfilefast \
+  --env CONVERTFILEFAST_API_KEY=cff_REPLACE_WITH_YOUR_KEY \
+  -- "C:\Projetos\GitHub-Clones\conversor-pdf\mcp\.venv\Scripts\python.exe" \
+     "C:\Projetos\GitHub-Clones\conversor-pdf\mcp\server.py"
+```
+
+> **Testing against the local backend:** add
+> `"CONVERTFILEFAST_API_BASE": "http://127.0.0.1:8000"` to the `env` block and
+> start the backend first (`uvicorn app.main:app` from `api/`).
+
+## Future: published install
+
+Once published to PyPI, the portable, machine-independent config will be:
+
+```json
+{
+  "mcpServers": {
+    "convertfilefast": {
+      "command": "uvx",
+      "args": ["convertfilefast-mcp"],
+      "env": { "CONVERTFILEFAST_API_KEY": "cff_..." }
+    }
+  }
+}
+```
+
+## Development
+
+```bash
+# from this directory
+uv venv .venv --python 3.12
+uv pip install --python .venv/Scripts/python.exe fastmcp httpx
+
+# run (stdio)
+CONVERTFILEFAST_API_KEY=cff_... .venv/Scripts/python.exe server.py
+```
+
+Inspect the tools with the MCP Inspector:
+
+```bash
+npx @modelcontextprotocol/inspector .venv/Scripts/python.exe server.py
+```

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

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: convertfilefast-mcp
+Version: 0.1.0
+Summary: MCP server for ConvertFileFast — convert 50+ file formats and run PDF/image operations as AI-agent tools.
+Author: ConvertFileFast
+License: MIT
+Keywords: mcp,model-context-protocol,pdf,file-conversion,convert,agents
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastmcp>=3.0
+Requires-Dist: httpx>=0.27
+
+# ConvertFileFast MCP server
+
+An [MCP](https://modelcontextprotocol.io) server that lets AI agents (Claude
+Desktop, Claude Code, Cursor, etc.) convert files and run PDF/image operations
+through the ConvertFileFast API.
+
+It is a **separate service** that talks to the ConvertFileFast REST API over
+HTTP — it does not import the backend, so it never affects the API's
+dependencies, and it mirrors how the hosted MCP runs in production.
+
+## Tools
+
+| Tool | What it does |
+|------|--------------|
+| `convert_file` | Convert between 40+ format pairs (DOCX→PDF, PDF→CSV, PDF→JPG, HTML→PDF, URL→PDF, PNG→JPG, CSV→JSON, …) |
+| `merge_pdfs` | Merge multiple PDFs into one |
+| `split_pdf` | Extract pages/ranges from a PDF |
+| `compress_pdf` | Reduce PDF size (low/medium/high/maximum) |
+| `rotate_pdf` | Rotate pages (90/180/270°) |
+| `protect_pdf` | Add password protection |
+| `unlock_pdf` | Remove password protection |
+| `resize_image` | Resize an image |
+| `compress_image` | Compress an image (and optionally cap dimensions) |
+
+Every tool accepts a public `source_url` (preferred — the agent passes a URL and
+never handles binary) **or** `file_base64`. The result file is written to the
+output directory and the tool returns its path.
+
+## Prerequisites
+
+A ConvertFileFast API key (starts with `cff_`). Create one at
+<https://www.convertfilefast.com/signup>.
+
+## Configuration
+
+The server reads these environment variables:
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `CONVERTFILEFAST_API_KEY` | — | Your `cff_` key (sent as `X-API-Key`) |
+| `CONVERTFILEFAST_API_BASE` | `https://api.convertfilefast.com` | API base URL (set to `http://127.0.0.1:8000` to test against a local backend) |
+| `CONVERTFILEFAST_OUTPUT_DIR` | `~/ConvertFileFast` | Where converted files are saved |
+| `CONVERTFILEFAST_TIMEOUT` | `180` | Per-request timeout (seconds) |
+
+## Install (local, works today)
+
+Until the package is published to PyPI, point your MCP client at the local
+virtual environment created for this repo.
+
+### Claude Desktop
+
+Edit `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "convertfilefast": {
+      "command": "C:\\Projetos\\GitHub-Clones\\conversor-pdf\\mcp\\.venv\\Scripts\\python.exe",
+      "args": ["C:\\Projetos\\GitHub-Clones\\conversor-pdf\\mcp\\server.py"],
+      "env": {
+        "CONVERTFILEFAST_API_KEY": "cff_REPLACE_WITH_YOUR_KEY"
+      }
+    }
+  }
+}
+```
+
+Restart Claude Desktop, then ask: *"Convert https://example.com/report.docx to PDF."*
+
+### Cursor
+
+Add the same block to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (per
+project).
+
+### Claude Code
+
+```bash
+claude mcp add convertfilefast \
+  --env CONVERTFILEFAST_API_KEY=cff_REPLACE_WITH_YOUR_KEY \
+  -- "C:\Projetos\GitHub-Clones\conversor-pdf\mcp\.venv\Scripts\python.exe" \
+     "C:\Projetos\GitHub-Clones\conversor-pdf\mcp\server.py"
+```
+
+> **Testing against the local backend:** add
+> `"CONVERTFILEFAST_API_BASE": "http://127.0.0.1:8000"` to the `env` block and
+> start the backend first (`uvicorn app.main:app` from `api/`).
+
+## Future: published install
+
+Once published to PyPI, the portable, machine-independent config will be:
+
+```json
+{
+  "mcpServers": {
+    "convertfilefast": {
+      "command": "uvx",
+      "args": ["convertfilefast-mcp"],
+      "env": { "CONVERTFILEFAST_API_KEY": "cff_..." }
+    }
+  }
+}
+```
+
+## Development
+
+```bash
+# from this directory
+uv venv .venv --python 3.12
+uv pip install --python .venv/Scripts/python.exe fastmcp httpx
+
+# run (stdio)
+CONVERTFILEFAST_API_KEY=cff_... .venv/Scripts/python.exe server.py
+```
+
+Inspect the tools with the MCP Inspector:
+
+```bash
+npx @modelcontextprotocol/inspector .venv/Scripts/python.exe server.py
+```

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

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+server.py
+convertfilefast_mcp.egg-info/PKG-INFO
+convertfilefast_mcp.egg-info/SOURCES.txt
+convertfilefast_mcp.egg-info/dependency_links.txt
+convertfilefast_mcp.egg-info/entry_points.txt
+convertfilefast_mcp.egg-info/requires.txt
+convertfilefast_mcp.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+convertfilefast-mcp = server:main

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

@@ -0,0 +1,2 @@
+fastmcp>=3.0
+httpx>=0.27

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

@@ -0,0 +1 @@
+server

convertfilefast_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "convertfilefast-mcp"
+version = "0.1.0"
+description = "MCP server for ConvertFileFast — convert 50+ file formats and run PDF/image operations as AI-agent tools."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "ConvertFileFast" }]
+keywords = ["mcp", "model-context-protocol", "pdf", "file-conversion", "convert", "agents"]
+dependencies = [
+    "fastmcp>=3.0",
+    "httpx>=0.27",
+]
+
+[project.scripts]
+convertfilefast-mcp = "server:main"
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+py-modules = ["server"]

convertfilefast_mcp-0.1.0/server.py

@@ -0,0 +1,355 @@
+"""ConvertFileFast MCP server.
+
+Exposes file conversion as tools for AI agents (Claude, Cursor, ChatGPT, ...).
+
+This is a *separate service* from the REST backend: it talks to the
+ConvertFileFast HTTP API and never imports the backend (keeps the backend's
+dependencies untouched and matches how the hosted MCP runs in production).
+
+Auth: the caller's ConvertFileFast API key (prefix ``cff_``), taken from the
+``CONVERTFILEFAST_API_KEY`` environment variable and sent as ``X-API-Key``.
+
+Configuration (env vars):
+  CONVERTFILEFAST_API_BASE   API base URL (default: production API)
+  CONVERTFILEFAST_API_KEY    the cff_ key used for requests
+  CONVERTFILEFAST_OUTPUT_DIR where converted files are written (default ~/ConvertFileFast)
+  CONVERTFILEFAST_TIMEOUT    per-request timeout in seconds (default 180)
+"""
+
+from __future__ import annotations
+
+import base64
+import os
+import re
+from pathlib import Path
+from typing import Annotated, Literal, Optional
+from urllib.parse import urlparse
+
+import httpx
+from fastmcp import FastMCP
+from pydantic import Field
+
+API_BASE = os.environ.get("CONVERTFILEFAST_API_BASE", "https://api.convertfilefast.com").rstrip("/")
+API_KEY = os.environ.get("CONVERTFILEFAST_API_KEY", "")
+OUTPUT_DIR = Path(os.environ.get("CONVERTFILEFAST_OUTPUT_DIR", str(Path.home() / "ConvertFileFast")))
+HTTP_TIMEOUT = float(os.environ.get("CONVERTFILEFAST_TIMEOUT", "180"))
+
+mcp = FastMCP(
+    "ConvertFileFast",
+    instructions=(
+        "Convert files between 50+ formats and run PDF/image operations "
+        "(merge, split, compress, rotate, protect, unlock, resize). Prefer "
+        "passing a public URL via `source_url`; otherwise pass base64. The "
+        "result file is saved locally and the tool returns its path."
+    ),
+)
+
+# --- Conversion matrix (mirrors the backend's /v2/convert/{from}-to-{to}) ---
+_DOC_TO_PDF = ["docx", "doc", "xlsx", "pptx", "ppt", "rtf", "odt", "txt", "csv"]
+_WEB_TO_PDF = ["html", "markdown", "url"]
+_IMG_TO_PDF = ["jpg", "png", "heic", "webp", "avif", "svg", "bmp", "tiff"]
+_PDF_TARGETS = ["docx", "txt", "csv", "xlsx", "jpg", "png"]
+_IMG_TO_IMG = [
+    "jpg-to-png", "png-to-jpg", "jpg-to-webp", "png-to-webp",
+    "heic-to-jpg", "heic-to-png", "webp-to-jpg", "webp-to-png",
+    "avif-to-jpg", "avif-to-png", "svg-to-png", "svg-to-jpg",
+    "bmp-to-jpg", "bmp-to-png", "tiff-to-jpg", "tiff-to-png",
+]
+_DATA = ["csv-to-json", "json-to-csv", "csv-to-xlsx", "xlsx-to-csv"]
+
+VALID_SLUGS: set[str] = set(_IMG_TO_IMG) | set(_DATA)
+for _s in _DOC_TO_PDF + _WEB_TO_PDF + _IMG_TO_PDF:
+    VALID_SLUGS.add(f"{_s}-to-pdf")
+for _t in _PDF_TARGETS:
+    VALID_SLUGS.add(f"pdf-to-{_t}")
+
+_EXT_ALIAS = {"jpeg": "jpg", "tif": "tiff", "md": "markdown", "htm": "html", "text": "txt"}
+
+TargetFormat = Literal["pdf", "docx", "xlsx", "csv", "txt", "json", "jpg", "png", "webp"]
+
+
+# --------------------------------------------------------------------------- #
+# Helpers
+# --------------------------------------------------------------------------- #
+def _client() -> httpx.Client:
+    headers = {"User-Agent": "convertfilefast-mcp"}
+    if API_KEY:
+        headers["X-API-Key"] = API_KEY
+    return httpx.Client(base_url=API_BASE, headers=headers, timeout=HTTP_TIMEOUT)
+
+
+def _formval(v: object) -> str:
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    return str(v)
+
+
+def _filename_from_response(resp: httpx.Response, fallback: str) -> str:
+    cd = resp.headers.get("content-disposition", "")
+    m = re.search(r"filename\*?=(?:UTF-8'')?\"?([^\";]+)\"?", cd)
+    return os.path.basename(m.group(1)) if m else fallback
+
+
+def _deliver(content: bytes, out_name: str) -> dict:
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    out_path = OUTPUT_DIR / out_name
+    out_path.write_bytes(content)
+    return {"status": "success", "output_path": str(out_path), "filename": out_name, "bytes": len(content)}
+
+
+def _error(resp: httpx.Response) -> dict:
+    try:
+        detail = resp.json().get("detail", resp.text[:300])
+    except Exception:
+        detail = resp.text[:300]
+    hint = None
+    if resp.status_code in (401, 403):
+        hint = "Set a valid CONVERTFILEFAST_API_KEY (cff_...)."
+    elif resp.status_code == 429:
+        hint = "Rate or credit limit reached. Add credits or slow down."
+    return {"status": "error", "http_status": resp.status_code, "detail": detail, "hint": hint}
+
+
+def _send(
+    endpoint: str,
+    *,
+    default_out: str,
+    source_url: Optional[str] = None,
+    file_base64: Optional[str] = None,
+    filename: Optional[str] = None,
+    extra: Optional[dict] = None,
+) -> dict:
+    """POST to a conversion/operation endpoint with url-or-upload input."""
+    data: dict[str, str] = {k: _formval(v) for k, v in (extra or {}).items() if v is not None}
+    files = None
+    if source_url:
+        data["url"] = source_url
+    elif file_base64:
+        try:
+            raw = base64.b64decode(file_base64)
+        except Exception:
+            return {"status": "error", "detail": "file_base64 is not valid base64."}
+        files = {"file": (filename or "input", raw)}
+    else:
+        return {"status": "error", "detail": "Provide either source_url or file_base64."}
+
+    try:
+        with _client() as c:
+            resp = c.post(endpoint, data=data, files=files)
+    except httpx.RequestError as e:
+        return {"status": "error", "detail": f"Request to API failed: {e}"}
+
+    if resp.status_code != 200:
+        return _error(resp)
+    return _deliver(resp.content, _filename_from_response(resp, default_out))
+
+
+def _guess_source_format(source_url: Optional[str], filename: Optional[str], target: str) -> Optional[str]:
+    name = filename or (urlparse(source_url).path if source_url else "")
+    ext = Path(name).suffix.lower().lstrip(".")
+    ext = _EXT_ALIAS.get(ext, ext)
+    if ext:
+        return ext
+    if source_url and target == "pdf":
+        return "url"  # a URL with no file extension, to PDF, is a webpage
+    return None
+
+
+# --------------------------------------------------------------------------- #
+# Tools
+# --------------------------------------------------------------------------- #
+@mcp.tool(annotations={"idempotentHint": True, "openWorldHint": True})
+def convert_file(
+    target_format: Annotated[TargetFormat, Field(description="Desired output format, e.g. 'pdf', 'csv', 'png'.")],
+    source_url: Annotated[Optional[str], Field(description="Public URL to the source file or webpage (preferred). For a webpage to PDF, point at the page and use target_format='pdf'.")] = None,
+    file_base64: Annotated[Optional[str], Field(description="Base64-encoded source file. Use only when there is no URL.")] = None,
+    filename: Annotated[Optional[str], Field(description="Original filename (with extension); used to detect the source format and name the output.")] = None,
+    source_format: Annotated[Optional[str], Field(description="Source format token (e.g. 'docx', 'pdf', 'png', 'html', 'url'). Inferred from filename/URL if omitted.")] = None,
+) -> dict:
+    """Convert a document, spreadsheet, presentation, image, PDF, or data file to another format.
+
+    Supports 40+ conversions, e.g. DOCX->PDF, PDF->CSV, PDF->JPG, HTML->PDF,
+    URL(webpage)->PDF, PNG->JPG, CSV->JSON. Pass a public `source_url` (preferred)
+    or `file_base64`. Returns the local path of the converted file.
+    """
+    src = (source_format or _guess_source_format(source_url, filename, target_format) or "").lower()
+    src = _EXT_ALIAS.get(src, src)
+    if not src:
+        return {"status": "error", "detail": "Could not determine the source format. Pass `source_format` (e.g. 'docx') or a `filename` with an extension."}
+
+    slug = f"{src}-to-{target_format}"
+    if slug not in VALID_SLUGS:
+        valid_targets = sorted(s.split("-to-")[1] for s in VALID_SLUGS if s.startswith(f"{src}-to-"))
+        return {"status": "error", "detail": f"Conversion '{slug}' is not supported.", "supported_targets_for_source": valid_targets or None}
+
+    stem = Path(filename).stem if filename else "converted"
+    return _send(f"/v2/convert/{slug}", default_out=f"{stem}.{target_format}",
+                 source_url=source_url, file_base64=file_base64, filename=filename)
+
+
+@mcp.tool(annotations={"idempotentHint": True, "openWorldHint": True})
+def merge_pdfs(
+    source_urls: Annotated[Optional[list[str]], Field(description="Public URLs of the PDFs to merge, in order (minimum 2).")] = None,
+    files_base64: Annotated[Optional[list[str]], Field(description="Base64-encoded PDFs to merge, in order (minimum 2). Use when there are no URLs.")] = None,
+    output_name: Annotated[str, Field(description="Name for the merged PDF.")] = "merged.pdf",
+) -> dict:
+    """Merge multiple PDFs into a single PDF, preserving the given order."""
+    blobs: list[tuple[str, bytes]] = []
+    if files_base64:
+        for i, b in enumerate(files_base64):
+            try:
+                blobs.append((f"part{i + 1}.pdf", base64.b64decode(b)))
+            except Exception:
+                return {"status": "error", "detail": f"files_base64[{i}] is not valid base64."}
+    elif source_urls:
+        try:
+            with httpx.Client(timeout=HTTP_TIMEOUT, follow_redirects=True) as fetch:
+                for i, u in enumerate(source_urls):
+                    rr = fetch.get(u)
+                    if rr.status_code != 200:
+                        return {"status": "error", "detail": f"Could not fetch {u} (HTTP {rr.status_code})."}
+                    blobs.append((f"part{i + 1}.pdf", rr.content))
+        except httpx.RequestError as e:
+            return {"status": "error", "detail": f"Failed to fetch a URL: {e}"}
+    else:
+        return {"status": "error", "detail": "Provide source_urls or files_base64 (at least 2 PDFs)."}
+
+    if len(blobs) < 2:
+        return {"status": "error", "detail": "Need at least 2 PDFs to merge."}
+
+    files = [("files", (name, data)) for name, data in blobs]
+    try:
+        with _client() as c:
+            resp = c.post("/v2/pdf/merge", files=files)
+    except httpx.RequestError as e:
+        return {"status": "error", "detail": f"Request to API failed: {e}"}
+    if resp.status_code != 200:
+        return _error(resp)
+    return _deliver(resp.content, _filename_from_response(resp, output_name))
+
+
+@mcp.tool(annotations={"idempotentHint": True, "openWorldHint": True})
+def split_pdf(
+    pages: Annotated[str, Field(description="Pages/ranges to extract, e.g. '1,3,5-7' or '1-5'.")],
+    source_url: Annotated[Optional[str], Field(description="Public URL of the PDF.")] = None,
+    file_base64: Annotated[Optional[str], Field(description="Base64-encoded PDF.")] = None,
+) -> dict:
+    """Extract specific pages/ranges from a PDF (returns the resulting file(s))."""
+    return _send("/v2/pdf/split", default_out="split.zip", source_url=source_url,
+                 file_base64=file_base64, extra={"pages": pages})
+
+
+@mcp.tool(annotations={"idempotentHint": True, "openWorldHint": True})
+def compress_pdf(
+    source_url: Annotated[Optional[str], Field(description="Public URL of the PDF.")] = None,
+    file_base64: Annotated[Optional[str], Field(description="Base64-encoded PDF.")] = None,
+    quality: Annotated[Literal["low", "medium", "high", "maximum"], Field(description="Compression preset (more compression = smaller file).")] = "medium",
+    remove_metadata: Annotated[bool, Field(description="Strip PDF metadata to reduce size further.")] = False,
+) -> dict:
+    """Reduce the file size of a PDF."""
+    return _send("/v2/pdf/compress", default_out="compressed.pdf", source_url=source_url,
+                 file_base64=file_base64, extra={"quality": quality, "remove_metadata": remove_metadata})
+
+
+@mcp.tool(annotations={"idempotentHint": True, "openWorldHint": True})
+def rotate_pdf(
+    angle: Annotated[Literal[90, 180, 270], Field(description="Rotation in degrees (clockwise).")],
+    source_url: Annotated[Optional[str], Field(description="Public URL of the PDF.")] = None,
+    file_base64: Annotated[Optional[str], Field(description="Base64-encoded PDF.")] = None,
+    pages: Annotated[Optional[str], Field(description="Pages to rotate, e.g. '1,3,5-7'. Omit to rotate all pages.")] = None,
+) -> dict:
+    """Rotate pages in a PDF."""
+    return _send("/v2/pdf/rotate", default_out="rotated.pdf", source_url=source_url,
+                 file_base64=file_base64, extra={"angle": angle, "pages": pages})
+
+
+@mcp.tool(annotations={"idempotentHint": True, "openWorldHint": True})
+def protect_pdf(
+    password: Annotated[str, Field(description="Password to set on the PDF.")],
+    source_url: Annotated[Optional[str], Field(description="Public URL of the PDF.")] = None,
+    file_base64: Annotated[Optional[str], Field(description="Base64-encoded PDF.")] = None,
+) -> dict:
+    """Add password protection (encryption) to a PDF."""
+    return _send("/v2/pdf/protect", default_out="protected.pdf", source_url=source_url,
+                 file_base64=file_base64, extra={"password": password})
+
+
+@mcp.tool(annotations={"idempotentHint": True, "openWorldHint": True})
+def unlock_pdf(
+    password: Annotated[str, Field(description="Current password of the PDF.")],
+    source_url: Annotated[Optional[str], Field(description="Public URL of the PDF.")] = None,
+    file_base64: Annotated[Optional[str], Field(description="Base64-encoded PDF.")] = None,
+) -> dict:
+    """Remove password protection from a PDF (requires the current password)."""
+    return _send("/v2/pdf/unlock", default_out="unlocked.pdf", source_url=source_url,
+                 file_base64=file_base64, extra={"password": password})
+
+
+@mcp.tool(annotations={"idempotentHint": True, "openWorldHint": True})
+def resize_image(
+    source_url: Annotated[Optional[str], Field(description="Public URL of the image.")] = None,
+    file_base64: Annotated[Optional[str], Field(description="Base64-encoded image.")] = None,
+    width: Annotated[Optional[int], Field(description="Target width in pixels.")] = None,
+    height: Annotated[Optional[int], Field(description="Target height in pixels.")] = None,
+    fit: Annotated[Literal["contain", "cover", "fill"], Field(description="How to fit within width/height.")] = "contain",
+    format: Annotated[Optional[str], Field(description="Output format (jpeg, png, webp, ...). Defaults to source format.")] = None,
+) -> dict:
+    """Resize an image to the given width/height."""
+    if width is None and height is None:
+        return {"status": "error", "detail": "Provide at least one of width or height."}
+    return _send("/v2/image/resize", default_out="resized.png", source_url=source_url,
+                 file_base64=file_base64, extra={"width": width, "height": height, "fit": fit, "format": format})
+
+
+@mcp.tool(annotations={"idempotentHint": True, "openWorldHint": True})
+def compress_image(
+    source_url: Annotated[Optional[str], Field(description="Public URL of the image.")] = None,
+    file_base64: Annotated[Optional[str], Field(description="Base64-encoded image.")] = None,
+    quality: Annotated[int, Field(description="Compression quality 1-100 (higher = better quality, larger file).", ge=1, le=100)] = 85,
+    format: Annotated[Optional[str], Field(description="Output format (jpeg, png, webp, ...). Defaults to source format.")] = None,
+    max_width: Annotated[Optional[int], Field(description="Optionally cap the width in pixels.")] = None,
+    max_height: Annotated[Optional[int], Field(description="Optionally cap the height in pixels.")] = None,
+) -> dict:
+    """Compress an image to reduce file size, optionally capping its dimensions."""
+    return _send("/v2/image/compress", default_out="compressed.png", source_url=source_url,
+                 file_base64=file_base64,
+                 extra={"quality": quality, "format": format, "max_width": max_width, "max_height": max_height})
+
+
+@mcp.tool(annotations={"idempotentHint": False, "openWorldHint": True})
+def report_issue(
+    summary: Annotated[str, Field(description="What went wrong or what's missing. Be specific.")],
+    category: Annotated[
+        Literal["bug", "missing_conversion", "quality", "other"],
+        Field(description="Type of feedback."),
+    ] = "other",
+    tool: Annotated[Optional[str], Field(description="Which tool/conversion this is about, e.g. 'convert_file docx-to-pdf'.")] = None,
+    context: Annotated[Optional[str], Field(description="Extra detail: error message, input format, expected vs actual output.")] = None,
+) -> dict:
+    """Report a bug, missing conversion, or quality issue with ConvertFileFast to the maintainers.
+
+    Use this when a conversion fails, a format you need isn't supported, or the
+    output quality is poor. Your report goes into the team's development backlog.
+    """
+    data: dict[str, str] = {"summary": summary, "category": category}
+    if tool:
+        data["tool"] = tool
+    if context:
+        data["context"] = context
+    try:
+        with _client() as c:
+            resp = c.post("/v2/feedback", data=data)
+    except httpx.RequestError as e:
+        return {"status": "error", "detail": f"Could not send feedback: {e}"}
+    if resp.status_code != 200:
+        return _error(resp)
+    return {"status": "received", "message": "Thanks — your report was logged for the ConvertFileFast team."}
+
+
+def main() -> None:
+    """Console-script / module entry point. Runs the stdio MCP server."""
+    mcp.run()  # stdio transport by default
+
+
+if __name__ == "__main__":
+    main()

convertfilefast_mcp-0.1.0/setup.cfg

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