TweekIT v1.8.0 Official Release: PyPI Python SDK, 8-Tool MCP Server, TLS/OIDC Supply-Chain Hardening, and CPUcoin MAITRIX Ultimate AI Hub Architecture

The official TweekIT Python SDK and MCP Server (v1.8.0) is now live on PyPI under the AMPS dba Equilibrium organization — uniting our FastMCP 3.0 server, zero-hop async Python SDK, 347-extension local AI Hub preflight router (backed by 450+ live MediaRich formats), ABI-resilient Claude .mcpb desktop extension, and hardened TLS/OIDC release posture in a single open-source package.

Earlier this year, we launched the hosted TweekIT-MCP Server and integrated universal multimodal ingestion across MAITRIX, CPUcoin’s Ultimate AI Hub. Since that initial v1.5.0 release, engineering teams building autonomous agents, RAG pipelines, and multi-model orchestration gateways have asked for three things:

1. First-class PyPI packaging with both direct async REST clients (no MCP intermediary hop required) and concurrent MCP client helpers.
2. Zero-latency modality preflight & local file tooling so agents know before uploading whether a .dwg, .psd, .cr3, .indd, or .xlsb file requires normalization for a specific target LLM — and can convert local files without stuffing megabytes of base64 into the prompt context window.
3. Hardened release workflows and up-to-date TLS trust stores across Python wheels, Docker/Cloud Run images, and desktop .mcpb bundles.

Today we are excited to announce the general availability of TweekIT MCP Server & Python SDK v1.8.0 on PyPI (pypi.org/project/tweekit/1.8.0/) and GitHub (equilibrium-team/tweekit-mcp). Below is a full technical walkthrough of everything shipping in v1.8.0 (incorporating all v1.6.1–v1.8.0 milestones), our supply-chain and certificate security architecture, and how TweekIT powers real-time multimodal routing inside the CPUcoin MAITRIX Ultimate AI Hub (maitrix.io).

1. Official PyPI Release (pip install tweekit)

tweekit v1.8.0 is published under the AMPS dba Equilibrium organization on PyPI (pypi.org/org/equilibrium/). A single install provides both CLI executables (tweekit and tweekit-mcp) and both Python import namespaces (import tweekit and import tweekit_mcp), supporting Python 3.10 through 3.14+.

# Standard pip install
pip install tweekit

# Fast install with Astral uv
uv pip install tweekit

# Launch as a local stdio MCP server via uvx (preflight/fetch/search work without keys;
# set TWEEKIT_API_KEY and TWEEKIT_API_SECRET for conversion & doctype tools)
uvx tweekit --transport stdio

# Install globally as an isolated CLI tool (exposes both `tweekit` and `tweekit-mcp`)
uv tool install tweekit

To run a stateless streamable HTTP MCP server locally or inside your own VPC:

export TWEEKIT_API_KEY="<TWEEKIT_API_KEY>"
export TWEEKIT_API_SECRET="<TWEEKIT_API_SECRET>"

tweekit-mcp --transport streamable-http --host 0.0.0.0 --port 8080

Under the hood, v1.8.0 upgrades to FastMCP 3.0+ (fastmcp>=3.0.0) with stateless_http=True enabled across local HTTP, Google Cloud Run, and Firebase Hosting deployments — eliminating sticky-session state overhead and enabling horizontal autoscaling from zero.

2. Full Async Python SDK: TweekitDirectClient & TweekitClient

Prior to v1.8.0, developers embedding TweekIT into Python backends either wrote raw httpx boilerplate against the REST API or stood up an MCP client session even for deterministic backend pipelines. tweekit v1.8.0 ships two purpose-built async SDK clients plus synchronous preflight utilities:

• preflight_check / recommend_ai_format: Pure-Python, zero-network-roundtrip file classification across 347 static extensions (EXTENSIVE_SUPPORTED_EXTENSIONS, spanning 12 media families) with provider-specific output format and parameter recommendations — backed by 450+ formats in the live MediaRich engine via doctype.
• TweekitDirectClient: Calls the TweekIT MediaRich REST engine directly over httpx with zero MCP protocol overhead — ideal for high-throughput ingestion workers, ETL jobs, and backend microservices.
• TweekitClient: Wraps the FastMCP async client against https://mcp.tweekit.io/mcp (or any custom/stdio server) and adds semaphore-controlled batch_convert() for concurrent multi-asset normalization across local paths, remote URLs, and raw byte buffers.

import asyncio
from pathlib import Path
from tweekit import (
    TweekitClient,
    TweekitDirectClient,
    preflight_check,
)

# 1. Instant local preflight & AI provider format routing (0 ms network cost)
route = preflight_check("turbine_assembly.dwg", target_provider="claude")
print(route["supported"], route["category"], route["recommended_outfmt"])
# -> True design_vector_cad png

# 2. Direct Async REST SDK (no MCP intermediary hop required)
async def normalize_direct() -> None:
    async with TweekitDirectClient() as api:
        receipt = await api.convert_file(
            Path("board_deck.ppt"),
            outfmt="pdf",
            no_rasterize=True,
            output_path=Path("board_deck_ai_ready.pdf"),
        )
        print("Normalized directly to disk:", receipt)

# 3. Async MCP SDK with semaphore-governed concurrent batch_convert
async def normalize_batch_mcp() -> None:
    async with TweekitClient() as mcp_client:
        tools = await mcp_client.list_tools()
        results = await mcp_client.batch_convert(
            [
                {"url": "https://example.com/archive_scan.tiff", "outfmt": "png", "width": 1600},
                {"path": "financial_model.xlsb", "outfmt": "pdf", "no_rasterize": True},
                {"path": "studio_shot.cr3", "outfmt": "webp", "width": 1200, "bgcolor": "#FFFFFF"},
            ],
            concurrency=5,
        )
        print(f"Connected ({len(tools)} tools); converted {len(results)} assets.")

async def main() -> None:
    await normalize_direct()
    await normalize_batch_mcp()

asyncio.run(main())

3. Expanded 8-Tool MCP Surface with Spec ToolAnnotations

The TweekIT MCP server has grown from its original 3 conversion tools into an 8-tool multimodal ingestion suite, with every tool now carrying explicit Model Context Protocol ToolAnnotations (readOnlyHint, destructiveHint, idempotentHint, openWorldHint). Autonomous agent runtimes (Claude Desktop, OpenAI Codex CLI, Cursor, Antigravity, Windsurf, and custom MCP hosts) use these annotations to auto-approve safe read-only preflight probes while gating destructive cleanup operations.

In addition, the server exposes two lightweight MCP resources — config://tweekit-version (live upstream MediaRich/TweekIT engine probe) and config://tweekit-mcp-version (1.8.0) — plus an updated FastAPI OpenAI / ChatGPT REST Plugin Proxy (plugin_proxy.py) adding GET /preflight, POST /convert-url, and DELETE /documents/{doc_id} with strict Content-Security-Policy headers.

4. Inside the CPUcoin MAITRIX Ultimate AI Hub Integration

When CPUcoin launched MAITRIX (maitrix.io) — the Ultimate AI Hub unifying 70+ frontier models from OpenAI, Anthropic, Google Gemini, xAI Grok, Meta Llama, Mistral, DeepSeek, Groq, and NVIDIA Nemotron inside a single web, iOS, Android, and desktop workspace — one architectural problem stood above all others: modality asymmetry across frontier models.

Every LLM provider enforces different native MIME rules:

• Drop an AutoCAD .dwg, Photoshop .psd, InDesign .indd, or Canon .cr3 Camera RAW file into a standard chat client and every frontier API rejects the request outright.
• Even for office documents (.doc, .xlsx, .pptx, .wpd, .odt, .vsdx), some model endpoints accept native PDF documents while vision-only model lanes (such as DeepSeek vision or specialized Mistral/open-weight vision endpoints) only accept raster image URLs (image/png, image/webp, image/jpeg).
• Worse, in MAITRIX, a user can switch agents mid-conversation — starting a design critique on Page 3 of an Illustrator package with GPT, switching to Claude for structural spec extraction, and handing off to Gemini or DeepSeek on the very next turn.

How FORMAT_TAXONOMY, AI_PROVIDER_PROFILES, and justTweekIT Solve Multi-Model Ingestion

tweekit v1.8.0 open-sources the exact 12-category, 347-extension local preflight taxonomy (FORMAT_TAXONOMY / EXTENSIVE_SUPPORTED_EXTENSIONS) and provider modality router (AI_PROVIDER_PROFILES) co-engineered with the MAITRIX platform (backed by 450+ dynamic MediaRich engine formats via doctype):

1. Taxonomy Classification Across 12 Media Families: Incoming attachments are classified across raster_image (HEIC, AVIF, JP2, EXR, HDR, JBIG2, TIFF, WBMP…), design_vector_cad (PSD, PSB, AI, EPS, CDR, DWG, DXF, IGES, STL…), camera_raw (CR2, CR3, NEF, ARW, DNG, RAF, ORF, RW2, IIQ…), document (DOC/DOCX, WPD, HWP/HWPX, DJVU, XPS, RTF, LaTeX…), spreadsheet (XLS/XLSB/XLSM, ODS, Numbers, Lotus 1-2-3, SYLK…), presentation (PPT/PPTX, Keynote, ODP…), diagram_publishing (Visio VSD/VSDX, InDesign INDD/IDML, QuarkXPress, FrameMaker…), ebook_help (EPUB, MOBI, AZW3, CHM…), email_message (EML, MSG, MBOX, VCF, ICS), web_code_data, archive, and audio_video.
2. Provider-Aware Output Selection: When a file isn’t natively supported by the active model, MAITRIX’s BaseProvider.justTweekIT() pipeline routes visual/CAD/RAW assets to high-fidelity png/webp derivatives, routes textual documents to noRasterize=True searchable PDFs for document-capable models (claude, openai, gemini, openrouter), and automatically renders multi-page documents page-by-page (TWEEKIT_DPI, TWEEKIT_DOCUMENT_PAGE_LIMIT) into crisp raster pages for vision-only models (deepseek, mistral image lanes) — even parsing natural-language page requests from the user’s prompt.
3. Content-Addressed Caching & Ephemeral Cleanup: MAITRIX computes a content hash of every uploaded source file so normalized page derivatives are reused instantly when switching models mid-chat, streams live "TweekIT: Normalizing..." progress updates to the user’s session, and invokes DELETE /api/image/{docId} (purgeTweekitDocument / delete_document) immediately if a multi-page job is cancelled or finishes early.
4. Decentralized Edge Compute via CPUcoin PoPW: Heavy rendering and format normalization execute through Equilibrium’s patented MediaRich® / MediaGen engine distributed across the CPUcoin Computing Global Network (CGN) — where enterprise Proof of Processed Work (PoPW) nodes inside SOC 2 / ISO 27001 data centers deliver up to 5× higher throughput and up to 90% lower compute cost than traditional hyperscale serverless functions.

5. PyPI Release Pipeline, OIDC Workflow & October 2026 TLS / CA Hardening

Security and supply-chain integrity are first-class engineering requirements in v1.8.0. This release incorporates comprehensive build, release, and TLS certificate hardening across every distribution channel:

• Equilibrium PyPI Organization & OIDC-First Release CI/CD: Releases of tweekit are published from equilibrium-team/tweekit-mcp under the Equilibrium (AMPS dba Equilibrium) PyPI organization. Our GitHub Actions release pipeline (.github/workflows/publish-pypi.yml) configures OIDC Trusted Publishing (pypa/gh-action-pypi-publish with permissions: id-token: write) as the primary automated release path (with scoped PYPI_API_TOKEN fallback), building reproducible wheels via uv build (uv>=0.13.5, pip>=26.2.2).
• October 2026 TLS / CA Trust-Store Hardening (certifi>=2026.10.19): To ensure outbound HTTPS verification uses Mozilla’s October 2026 root CA bundle, tweekit v1.8.0 raises its CA bundle floor to certifi>=2026.10.19 (certifi==2026.10.23 in uv.lock and desktop .mcpb bundles) across the Python SDK, FastMCP server, and Firebase Functions requirements, while refreshing OS ca-certificates (update-ca-certificates) inside our production Google Cloud Run container images (Dockerfile).
• Canonical Domain & CSP Lockdown: All package manifests, OpenAI/ChatGPT proxy Content-Security-Policy directives (connect-src and img-src), and privacy/legal metadata are strictly locked to Equilibrium’s canonical tweekit.io and mcp.tweekit.io origins.

6. ABI-Resilient Claude Desktop .mcpb Bundle & Multi-Client Setup

Desktop AI users on macOS and Linux frequently hit a subtle failure mode with compiled Python MCP extensions: when a package manager like Homebrew upgrades the system python3 binary (for example, from Python 3.14 to Python 3.15), static .mcpb bundles containing compiled Cython/Rust wheels such as pydantic_core (_pydantic_core.cpython-314-darwin.so) can fail at startup with ModuleNotFoundError.

In v1.8.0, scripts/build_claude_bundle.py introduces a pure-stdlib ABI-resilient bootstrap launcher inside dist/tweekit-claude.mcpb:

1. At startup, the launcher probes pydantic_core and fastmcp C-extension ABI compatibility in-process before importing the server.
2. If the host python3 minor version changed, it inspects the bundled wheel tags and seamlessly os.execve() re-execs into a matching local interpreter (e.g., /opt/homebrew/bin/python3.14), an isolated ~/.local/bin/tweekit-mcp tool binary, or uvx --from tweekit tweekit-mcp — preventing broken desktop connectors across Python minor-version upgrades and avoiding working-directory import collisions when launched from macOS protected folders.

Connect Any MCP Client in Seconds

Cursor (~/.cursor/mcp.json — Hosted Streamable HTTP):

{
  "mcpServers": {
    "tweekit": {
      "url": "https://mcp.tweekit.io/mcp",
      "headers": {
        "ApiKey": "${env:TWEEKIT_API_KEY}",
        "ApiSecret": "${env:TWEEKIT_API_SECRET}"
      }
    }
  }
}

Claude Desktop / Cursor / Antigravity (claude_desktop_config.json / mcp_config.json — Local stdio via PyPI + uvx):

{
  "mcpServers": {
    "tweekit": {
      "command": "uvx",
      "args": ["tweekit", "--transport", "stdio"],
      "env": {
        "TWEEKIT_API_KEY": "<TWEEKIT_API_KEY>",
        "TWEEKIT_API_SECRET": "<TWEEKIT_API_SECRET>"
      }
    }
  }
}

(On macOS GUI apps with a minimal PATH, point "command" to /opt/homebrew/bin/uvx or ~/.local/bin/uvx, or install dist/tweekit-claude.mcpb directly in Claude Desktop via Settings → Extensions.)

OpenAI Codex CLI (~/.codex/config.toml — forwards env vars without storing secrets on disk):

# Hosted Streamable HTTP endpoint (authenticated via env_http_headers)
[mcp_servers.tweekit]
url = "https://mcp.tweekit.io/mcp"
env_http_headers = { "ApiKey" = "TWEEKIT_API_KEY", "ApiSecret" = "TWEEKIT_API_SECRET" }

# Or local stdio server via uvx (v1.8.0+ exposes all 8 tools)
# [mcp_servers.tweekit]
# command = "uvx"
# args = ["tweekit", "--transport", "stdio"]
# env_vars = ["TWEEKIT_API_KEY", "TWEEKIT_API_SECRET"]

Get Started Today — 10,000 Free API Calls Included

Every new TweekIT developer account includes 10,000 free API calls with full access to all 8 MCP tools, the async Python SDK, and 450+ supported formats — no credit card required.

• Install from PyPI: pypi.org/project/tweekit/ (pip install tweekit)
• Equilibrium PyPI Organization: pypi.org/org/equilibrium/
• Source & Release Notes (v1.8.0): github.com/equilibrium-team/tweekit-mcp
• Hosted MCP Endpoint: https://mcp.tweekit.io/mcp
• Get Free API Credentials & Interactive Demo: tweekit.io
• Experience TweekIT Live Inside MAITRIX Ultimate AI Hub: maitrix.io
• Explore Enterprise On-Premises MediaRich & MCP Deployments: Contact Equilibrium Engineering · Supported File Formats · Developer Center