modulex-integrations

194 integrations · 2,140 actions · 20 categories
Pip-installable LangChain tool integrations for the ModuleX runtime — and any LangChain / LangGraph agent.

…and 160+ more — browse the full catalog at modulex.dev/integrations, or the source in src/modulex_integrations/tools/.

What is this?

Every integration in this package exposes one or more LangChain @tool functions together with the credential metadata the ModuleX runtime needs to drive its UI and execution: auth schemas (OAuth2, API key, bearer token, custom connections), environment-variable definitions, and credential test endpoints.

• One contract for everything — each integration is a pydantic IntegrationManifest with extra="forbid" on every model. A typo fails at import time, not at runtime.
• Discovered, not registered — the runtime finds integrations through the Python modulex.tools entry-point group. Installing the package is the whole wiring.
• Async and pass-through by design — HTTP tools use httpx.AsyncClient and return the provider's native response shapes as JSON-serializable dicts. Typed pydantic output models in each outputs.py give the LLM a real JSONSchema for every action's result.
• Works without ModuleX — the tools are plain LangChain StructuredTools. Load TOOLS from any integration and bind them to a LangChain or LangGraph agent directly.

Installation

pip install modulex-integrations

With every integration's optional SDK dependencies (database drivers etc.):

pip install "modulex-integrations[all]"

Quickstart

Discover everything the package ships:

from importlib.metadata import entry_points

for ep in entry_points(group="modulex.tools"):
    integration = ep.load()
    print(f"{integration.manifest.display_name}: {len(integration.TOOLS)} tools")

Or call a tool directly — every action is an async LangChain tool that returns a plain dict:

import asyncio
from modulex_integrations.tools.qdrant import list_collections

async def main() -> None:
    result = await list_collections.ainvoke({
        "auth_type": "custom",
        "auth_data": {
            "base_url": "https://xyz.eu-west.cloud.qdrant.io:6333",
            "api_key": "...",
        },
    })
    print(result)  # {"success": True, "collections": [...], "error": None}

asyncio.run(main())

Catalog

Each integration's own README.md documents its auth setup, tools, and limits — e.g. github, slack, qdrant.

Per-integration layout

Every integration ships in the same shape:

src/modulex_integrations/tools/<name>/
├── __init__.py        # re-exports manifest + TOOLS
├── manifest.py        # IntegrationManifest instance
├── tools.py           # LangChain @tool functions
├── outputs.py         # pydantic response models (UI/docs derive JSONSchema)
├── dependencies.toml  # per-integration runtime deps
├── README.md          # strict 5-section template
└── tests/
    └── test_<name>.py

The contract is enforced by the pydantic types in schema.py, and CI runs the full test suite plus ruff and mypy --strict on every PR.

Versioning & releases

Versions are derived from git tags via hatch-vcs — there is no static version field.

• Stable releases (vX.Y.Z) are tagged from main.
• Pre-releases (vX.Y.ZaN) are tagged from staging and land on PyPI as PEP 440 pre-releases.
• The ModuleX runtime consumes this package with exact pins per environment.

See RELEASING.md for the full process and CHANGELOG.md for what shipped in each version.

Contributing

Contributions flow through the standard GitHub PR model — adding a new integration is a single-repo PR. Start with CONTRIBUTING.md for the layout rules and README template, then verify locally:

git clone https://github.com/ModuleXAI/modulex-integrations.git
cd modulex-integrations
pip install -e ".[dev]"
pytest && ruff check src tests && mypy src/modulex_integrations

Links

• Website — modulex.dev
• Integration gallery — modulex.dev/integrations
• Documentation — docs.modulex.dev
• PyPI — pypi.org/project/modulex-integrations
• Issues — github.com/ModuleXAI/modulex-integrations/issues

License

MIT — see LICENSE.