> ## Documentation Index
> Fetch the complete documentation index at: https://docs.modulex.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Feature map

> Every ModuleX feature in one place — what each one does, where to use it, and the deep page that explains it. A skimmable matrix across building, AI, knowledge, integrations, collaboration, billing, and the developer API.

export const MediaEmbed = ({id, type = 'screenshot', caption = '', ext, ratio = '16 / 9'}) => {
  const isVideo = type === 'video' || type === 'app_video';
  const resolvedExt = ext || (isVideo ? 'mp4' : type === 'screenshot' ? 'webp' : 'svg');
  const src = 'https://media.modulex.dev/' + id + '.' + resolvedExt;
  const [status, setStatus] = useState('loading');
  const [isDev, setIsDev] = useState(false);
  const [inView, setInView] = useState(false);
  const boxRef = useRef(null);
  useEffect(() => {
    if (typeof window === 'undefined') return;
    const h = window.location.hostname;
    setIsDev(h === 'localhost' || h === '127.0.0.1' || h.endsWith('.mintlify.app'));
  }, []);
  useEffect(() => {
    if (inView) return;
    if (typeof IntersectionObserver === 'undefined') {
      setInView(true);
      return;
    }
    const el = boxRef.current;
    if (!el) return;
    const io = new IntersectionObserver(entries => {
      if (entries.some(e => e.isIntersecting)) {
        setInView(true);
        io.disconnect();
      }
    }, {
      rootMargin: '300px'
    });
    io.observe(el);
    return () => io.disconnect();
  }, [inView]);
  if (status === 'missing') {
    if (!isDev) return null;
    return <div style={{
      display: 'flex',
      flexDirection: 'column',
      justifyContent: 'center',
      gap: '0.4rem',
      padding: '1rem 1.25rem',
      margin: '1.25rem 0',
      width: '100%',
      aspectRatio: ratio,
      boxSizing: 'border-box',
      border: '1px dashed rgba(128,128,128,0.45)',
      borderRadius: '0.75rem',
      background: 'rgba(128,128,128,0.06)',
      color: 'currentColor',
      fontSize: '0.85rem',
      lineHeight: 1.45
    }}>
        <div style={{
      display: 'flex',
      alignItems: 'center',
      gap: '0.5rem',
      opacity: 0.75
    }}>
          <span aria-hidden="true">🎬</span>
          <code style={{
      fontSize: '0.75rem'
    }}>{id}</code>
          <span style={{
      fontSize: '0.65rem',
      textTransform: 'uppercase',
      letterSpacing: '0.04em',
      padding: '0.1rem 0.4rem',
      borderRadius: '0.4rem',
      background: 'rgba(128,128,128,0.18)'
    }}>
            {type}
          </span>
        </div>
        <div style={{
      opacity: 0.9
    }}>{caption || 'Media not uploaded yet.'}</div>
        <div style={{
      fontSize: '0.7rem',
      opacity: 0.5
    }}>
          Upload to R2 as <code>{id}.{resolvedExt}</code> — preview only, hidden in production.
        </div>
      </div>;
  }
  const mediaStyle = {
    display: status === 'loaded' ? 'block' : 'none',
    width: '100%',
    height: 'auto',
    borderRadius: '0.75rem'
  };
  const media = isVideo ? <video src={inView ? src : undefined} autoPlay loop muted playsInline preload="metadata" onLoadedData={() => setStatus('loaded')} onError={() => setStatus('missing')} style={mediaStyle} /> : <img src={inView ? src : undefined} alt={caption} onLoad={() => setStatus('loaded')} onError={() => setStatus('missing')} style={mediaStyle} />;
  return <figure style={{
    margin: '1.25rem 0'
  }}>
      <div ref={boxRef} style={status === 'loaded' ? {
    width: '100%'
  } : {
    width: '100%',
    aspectRatio: ratio,
    borderRadius: '0.75rem',
    background: 'rgba(128,128,128,0.06)'
  }}>
        {media}
      </div>
      {status === 'loaded' && caption ? <figcaption style={{
    marginTop: '0.5rem',
    textAlign: 'center',
    fontSize: '0.85rem',
    opacity: 0.7
  }}>
          {caption}
        </figcaption> : null}
    </figure>;
};

ModuleX is an AI workflow orchestration platform: you build workflows with natural language or a visual canvas, connect the tools you already use, and run them from chat, the API, or an SDK. This page is the index to all of it — every feature, what it does, and the one page that goes deep on it.

Use it two ways: skim the cards for an area you care about, or jump to the [feature matrix](#the-feature-matrix-at-a-glance) at the bottom for a single-table view.

<MediaEmbed id="MX-MEDIA-4350" type="image" caption={"A one-screen \"feature map\" diagram grouping ModuleX features into the seven areas on this page (Build, AI helpers, Knowledge, Integrations, Collaboration, Billing, Developer API)."} />

## How to read this map

Each card names a feature, says in one line what it does, and links to the page that explains it in full. Every feature has exactly one canonical home — start at the linked page when you want the details.

<CardGroup cols={3}>
  <Card title="Build workflows" icon="diagram-project" href="/workflow-builder/overview">
    The visual canvas and the nine node types that make up a workflow.
  </Card>

  <Card title="AI that builds and acts" icon="sparkles" href="/concepts/ai-composer">
    The AI Composer writes workflows for you; the Assistant gets work done in chat.
  </Card>

  <Card title="Knowledge and RAG" icon="book-open" href="/concepts/knowledge-rag">
    Connect your documents so AI answers from your own content.
  </Card>

  <Card title="Integrations" icon="plug" href="/integrations/overview">
    Connect 175 services and call their tools from workflows and agents.
  </Card>

  <Card title="Realtime collaboration" icon="users" href="/concepts/realtime-model">
    Co-edit the canvas live and watch runs stream as they happen.
  </Card>

  <Card title="Billing and credits" icon="wallet" href="/billing/overview">
    Plans, the credit model, and the wallet for managed usage.
  </Card>

  <Card title="Developer API and SDKs" icon="code" href="/api-reference/overview">
    Run everything from code with the REST API and the JavaScript and Python SDKs.
  </Card>

  <Card title="Security and enterprise" icon="shield-check" href="/security/overview">
    Organizations, roles, encryption, and enterprise deployment.
  </Card>
</CardGroup>

## Build workflows

A workflow is an editable graph of steps. You build it on a visual canvas, connect steps with edges, and pass data between them with references. Each step is a node, and each node writes its result back into the run's state.

<CardGroup cols={2}>
  <Card title="Workflow builder" icon="diagram-project" href="/workflow-builder/overview">
    The visual canvas where you lay out, connect, and run workflows.
  </Card>

  <Card title="Canvas and controls" icon="hand-pointer" href="/workflow-builder/canvas">
    Pan, zoom, select, the detail panel, and keyboard shortcuts.
  </Card>

  <Card title="Variables and references" icon="brackets-curly" href="/workflow-builder/variables-and-references">
    Pull a prior step's output into a later one with the reference syntax.
  </Card>

  <Card title="Versioning and history" icon="clock-rotate-left" href="/workflow-builder/versioning-history">
    Workflow versions, deployments, and the canvas edit history.
  </Card>

  <Card title="Error handling and retries" icon="triangle-exclamation" href="/workflow-builder/error-handling-retries">
    How node failures surface, retry behavior, and debugging failed runs.
  </Card>

  <Card title="Workflows and runs" icon="play" href="/concepts/workflows-and-runs">
    The core mental model: what a workflow is and what a run is.
  </Card>
</CardGroup>

### The nine node types

A workflow is built from nine node types. Each one does a specific job and writes its result into the run state under its own id.

<CardGroup cols={3}>
  <Card title="LLM node" icon="message-bot" href="/workflow-builder/nodes/llm">
    Call a language model with prompts, variables, and structured output.
  </Card>

  <Card title="Agent node" icon="robot" href="/workflow-builder/nodes/agent">
    Run an autonomous step that can call tools and loop.
  </Card>

  <Card title="Knowledge node" icon="book" href="/workflow-builder/nodes/knowledge">
    Retrieve from a knowledge base inside a workflow.
  </Card>

  <Card title="Tool node" icon="plug" href="/workflow-builder/nodes/tool">
    Call an integration action from one of the 175 connected services.
  </Card>

  <Card title="Function node" icon="function" href="/workflow-builder/nodes/function">
    Built-in HTTP requests, webhooks, and schema validation.
  </Card>

  <Card title="Conditional node" icon="code-branch" href="/workflow-builder/nodes/conditional">
    Branch on expressions or an LLM decision, or loop over data.
  </Card>

  <Card title="Interrupt node" icon="hand" href="/workflow-builder/nodes/interrupt">
    Pause a run to ask a human a question, then resume (human-in-the-loop).
  </Card>

  <Card title="Transformer node" icon="shuffle" href="/workflow-builder/nodes/transformer">
    Reshape, map, and combine data between steps.
  </Card>

  <Card title="Guardrails node" icon="shield" href="/workflow-builder/nodes/guardrails">
    Validate content with JSON, regex, and PII checks.
  </Card>
</CardGroup>

### Run and deploy

Once a workflow is built, you can run it from the builder, expose it as an API endpoint, trigger it from chat, or run it on a schedule.

<CardGroup cols={2}>
  <Card title="Running workflows" icon="circle-play" href="/workflow-builder/execution/running">
    Run from the builder and watch the live stream of events.
  </Card>

  <Card title="Deploy and versions" icon="rocket" href="/workflow-builder/execution/deploy">
    Deploy a workflow and manage its versions.
  </Card>

  <Card title="Schedules" icon="calendar" href="/workflow-builder/execution/schedule">
    Run a workflow automatically on a cron or interval schedule.
  </Card>

  <Card title="Run via API" icon="terminal" href="/workflow-builder/execution/api-endpoint">
    Trigger a workflow programmatically and stream its result.
  </Card>

  <Card title="Run from chat" icon="comments" href="/workflow-builder/execution/run-on-chat">
    Expose a workflow as a chat-triggered run.
  </Card>
</CardGroup>

## AI that builds and acts

ModuleX has two AI helpers. The **AI Composer** turns plain English into an editable workflow graph. The **Assistant** is an agentic chat that uses your connected tools to get work done, with no workflow required. Both pause for your approval before sensitive actions.

<CardGroup cols={2}>
  <Card title="AI Composer" icon="wand-magic-sparkles" href="/concepts/ai-composer">
    Describe a process in a prompt and get an editable workflow back.
  </Card>

  <Card title="Composer in the builder" icon="pen-ruler" href="/workflow-builder/composer">
    Generate and edit your workflow by chatting with the Composer copilot.
  </Card>

  <Card title="Assistant" icon="robot" href="/assistant/overview">
    An agentic chat that searches tools, drafts outputs, and acts step by step.
  </Card>

  <Card title="How the Assistant works" icon="diagram-next" href="/assistant/how-it-works">
    The agentic loop: how it reasons, picks tools, acts, and decides it is done.
  </Card>

  <Card title="Assistant tools" icon="screwdriver-wrench" href="/assistant/using-tools">
    How the Assistant discovers and calls integration tools.
  </Card>

  <Card title="Human-in-the-loop" icon="hand" href="/assistant/human-in-the-loop">
    How the Assistant pauses to ask for input or approval, and how you respond.
  </Card>

  <Card title="Streaming responses" icon="wave-pulse" href="/assistant/streaming">
    Stream the Assistant's actions and output live, in the app and the SDKs.
  </Card>

  <Card title="Models and settings" icon="sliders" href="/assistant/models-and-settings">
    Choose the model and configure how the Assistant behaves.
  </Card>
</CardGroup>

<Tip>
  The AI Composer and the Assistant are two sides of the same agent. The Composer edits a workflow graph for you; the Assistant has no workflow tools and instead acts directly through your connected integrations. Start with [AI Composer](/concepts/ai-composer) and [Assistant](/concepts/assistant) to learn which fits the job.
</Tip>

## Knowledge and RAG

Connect your own documents and ModuleX retrieves the relevant context automatically — in chat, in the Assistant, and inside workflows. You can use ModuleX-managed storage (billed in credits) or bring your own vector store.

<CardGroup cols={2}>
  <Card title="Knowledge and RAG" icon="book-open" href="/concepts/knowledge-rag">
    How retrieval works: knowledge bases, ingest, and answering from your content.
  </Card>

  <Card title="Knowledge overview" icon="books" href="/platform/knowledge/overview">
    Manage the knowledge bases that power retrieval across chats and workflows.
  </Card>

  <Card title="Managed knowledge" icon="database" href="/platform/knowledge/managed">
    ModuleX-hosted vector storage and retrieval, billed in credits.
  </Card>

  <Card title="External providers" icon="server" href="/platform/knowledge/external-providers">
    Bring your own vector store: Qdrant, Pinecone, MongoDB Atlas, or Weaviate.
  </Card>

  <Card title="Managing documents" icon="file-lines" href="/platform/knowledge/documents">
    Upload documents, watch them process, and manage chunks.
  </Card>

  <Card title="Chat with your knowledge" icon="comment-dots" href="/platform/chat/knowledge-chat">
    Ask questions answered from your connected knowledge bases.
  </Card>
</CardGroup>

<Note>
  The document upload limit is set by your plan's entitlement, not a fixed file size. See [managing documents](/platform/knowledge/documents) for what your plan allows.
</Note>

## Chat

The chat surface is where you talk to the Assistant, run workflows, and query your knowledge. Chats can be personal or shared with your organization.

<CardGroup cols={3}>
  <Card title="Chat overview" icon="comments" href="/platform/chat/overview">
    The chat surface for the Assistant, workflow runs, and knowledge.
  </Card>

  <Card title="Model selection" icon="layer-group" href="/platform/chat/model-selection">
    Choose the model for a chat — managed models or your own keys.
  </Card>

  <Card title="Run a workflow from chat" icon="play" href="/platform/chat/workflow-run">
    Trigger and watch a workflow run directly inside a chat.
  </Card>

  <Card title="Voice messages" icon="microphone" href="/platform/chat/voice-message">
    Send voice input in chat.
  </Card>

  <Card title="Private and org chat" icon="user-group" href="/platform/chat/private-org-chat">
    Personal versus organization-scoped chats and visibility.
  </Card>

  <Card title="History and folders" icon="folder" href="/platform/chat/history-folders">
    Organize chats with history and folders.
  </Card>
</CardGroup>

## Integrations

Connect ModuleX to the services you already use, then call their actions from workflows and the Assistant. The catalog has **175 integrations**.

<CardGroup cols={2}>
  <Card title="Integrations overview" icon="plug" href="/integrations/overview">
    Connect external services and call their tools from workflows and agents.
  </Card>

  <Card title="Integration catalog" icon="grid-2" href="/integrations/catalog">
    Browse all 175 integrations by category.
  </Card>

  <Card title="Authentication and credentials" icon="key" href="/integrations/authentication">
    How integrations authenticate: API keys, OAuth2, and the auth schema variants.
  </Card>

  <Card title="Managing credentials" icon="lock" href="/integrations/managing-credentials">
    Create, rotate, and scope credentials in the app and via the API.
  </Card>

  <Card title="LLM providers" icon="message-bot" href="/integrations/llm-providers/overview">
    Connect language-model providers — managed or bring your own key.
  </Card>

  <Card title="Knowledge providers" icon="database" href="/integrations/knowledge-providers/overview">
    The vector stores ModuleX can use for retrieval.
  </Card>

  <Card title="Build an integration" icon="hammer" href="/integrations/building/overview">
    Author your own ModuleX integration and expose its tools.
  </Card>

  <Card title="Custom MCP servers" icon="cube" href="/integrations/building/custom-mcp">
    Connect an external MCP server and use its tools in ModuleX.
  </Card>

  <Card title="ModuleX MCP" icon="upload" href="/api-reference/mcp/overview">
    Publish your workflows, Files, and Knowledge as tools for external AI clients.
  </Card>
</CardGroup>

<Warning>
  ModuleX does not yet ship per-tool install extras. Installing with extras like `[all]` or `[github,slack]` installs only the core package and can emit pip warnings. Install the base package instead — see [installing integrations](/integrations/install).
</Warning>

## Realtime collaboration

Work on a workflow with your team in realtime, and watch runs stream as they happen. The canvas syncs over a live connection so everyone sees the same graph.

<CardGroup cols={2}>
  <Card title="Realtime and collaboration model" icon="users" href="/concepts/realtime-model">
    How runs stream and how the canvas syncs between people.
  </Card>

  <Card title="Canvas collaboration" icon="user-pen" href="/platform/collaboration/canvas">
    Multiple people editing the same workflow canvas at once.
  </Card>

  <Card title="Realtime co-editing and external sync" icon="arrows-rotate" href="/workflow-builder/realtime-coediting">
    How canvas edits sync between collaborators and from external changes.
  </Card>

  <Card title="Presence, locks and versioning" icon="lock-open" href="/realtime/presence-locks">
    Presence, cursors, node locks, and the conflict model.
  </Card>

  <Card title="Chat collaboration" icon="comments" href="/platform/collaboration/chat">
    Shared and org-visible chats for teams.
  </Card>

  <Card title="Collaboration walkthrough" icon="route" href="/guides/realtime-collaboration">
    Invite a teammate and co-edit a workflow live, step by step.
  </Card>
</CardGroup>

## Billing and credits

Managed usage — runs, managed models, and managed knowledge — is priced in credits. Each organization gets a monthly credit allowance from its plan, and paid plans can spend a prepaid wallet beyond it. Bring-your-own-key usage is billed by the provider directly and is not metered in credits.

<CardGroup cols={2}>
  <Card title="Billing and credits overview" icon="wallet" href="/billing/overview">
    How ModuleX bills: plans, credits, the wallet, and the usage gate.
  </Card>

  <Card title="Plans and pricing" icon="tags" href="/billing/plans">
    Free, Pro, Max, and Enterprise — allowances, limits, and pricing.
  </Card>

  <Card title="Credits and metering" icon="coins" href="/billing/credits">
    What a credit is and exactly what consumes credits.
  </Card>

  <Card title="Usage gating and limits" icon="gauge-high" href="/billing/usage-gating">
    The admission gate and its denial responses on managed surfaces.
  </Card>

  <Card title="Wallet and top-ups" icon="piggy-bank" href="/billing/wallet">
    The prepaid wallet, manual top-ups, and auto-topup.
  </Card>

  <Card title="Subscriptions and Stripe" icon="credit-card" href="/billing/subscription-lifecycle">
    Subscription lifecycle, Stripe, and the customer portal.
  </Card>
</CardGroup>

<Note>
  Managed runs, the Assistant, the Composer, and managed knowledge pass through a live billing gate. When credits run out, those surfaces return a denial response (`402`, `403`, or `429`). Plain settings and CRUD routes are not gated. See [usage gating](/billing/usage-gating) and the [errors reference](/api-reference/errors).
</Note>

## Developer API and SDKs

Everything you do in the app is available from code. Authenticate with `Authorization: Bearer mx_live_…` plus the `X-Organization-ID` header, then call the REST API directly or through the JavaScript or Python SDK.

<CardGroup cols={2}>
  <Card title="API overview" icon="code" href="/api-reference/overview">
    Base URLs, the request lifecycle, and how every operation is shown.
  </Card>

  <Card title="Authentication" icon="key" href="/api-reference/authentication">
    Authenticate every request with a bearer key and the org header.
  </Card>

  <Card title="Errors and status codes" icon="circle-exclamation" href="/api-reference/errors">
    The error-envelope shapes and which surface emits each.
  </Card>

  <Card title="Rate limiting" icon="gauge" href="/api-reference/rate-limiting">
    Per-key and per-user rate limits, and the 429 responses.
  </Card>

  <Card title="SDKs overview" icon="cubes" href="/sdks/overview">
    The official JavaScript and Python SDKs, used across every operation.
  </Card>

  <Card title="SDK and API parity" icon="table-columns" href="/sdks/parity">
    A side-by-side map of REST routes to SDK methods, with gaps called out.
  </Card>

  <Card title="Streaming and HITL" icon="wave-pulse" href="/sdks/streaming-hitl">
    Consume run streams and answer human-in-the-loop prompts from the SDKs.
  </Card>

  <Card title="Realtime overview" icon="bolt" href="/realtime/overview">
    The two realtime planes: SSE run streaming and Socket.io collaboration.
  </Card>
</CardGroup>

A single workflow run, shown three ways. Swap the workflow id and your key:

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://api.modulex.dev/workflows/run \
    -H "Authorization: Bearer mx_live_REPLACE_WITH_YOUR_KEY" \
    -H "X-Organization-ID: org_2bQp9" \
    -H "Content-Type: application/json" \
    -d '{"workflow_id": "wf_8f2c1a", "input": {"topic": "quarterly sales summary"}}'
  ```

  ```python Python theme={null}
  from modulex import Modulex

  client = Modulex(
      api_key="mx_live_REPLACE_WITH_YOUR_KEY",
      organization_id="org_2bQp9",
  )

  run = await client.executions.run(
      workflow_id="wf_8f2c1a",
      input={"topic": "quarterly sales summary"},
  )
  print(run.run_id)
  ```

  ```javascript JavaScript theme={null}
  import { Modulex } from "modulex-js";

  const client = new Modulex({
    apiKey: "mx_live_REPLACE_WITH_YOUR_KEY",
    organizationId: "org_2bQp9",
  });

  const run = await client.executions.run({
    workflowId: "wf_8f2c1a",
    input: { topic: "quarterly sales summary" },
  });
  console.log(run.runId);
  ```
</CodeGroup>

<Note>
  The `subscriptions` resource is available in the Python SDK only. Manage subscriptions from Python or call the REST routes directly — see the [parity matrix](/sdks/parity).
</Note>

## Security, organizations, and enterprise

ModuleX is multi-tenant: every workflow, credential, knowledge base, and wallet belongs to an organization. Access is governed by org roles, and credentials are encrypted at rest.

<CardGroup cols={2}>
  <Card title="Security overview" icon="shield-check" href="/security/overview">
    How ModuleX secures your data, credentials, and access.
  </Card>

  <Card title="Organizations, roles and membership" icon="building" href="/concepts/organizations-roles">
    Tenancy in ModuleX: organizations, the org header, and roles.
  </Card>

  <Card title="Roles and permissions" icon="user-shield" href="/security/roles-permissions">
    Which actions require owner or admin.
  </Card>

  <Card title="Data security and encryption" icon="lock" href="/security/data-encryption">
    Encryption of credentials and secrets, and key management.
  </Card>

  <Card title="Trust and compliance" icon="certificate" href="/security/trust">
    Data handling, retention, and compliance posture.
  </Card>

  <Card title="ModuleX for enterprise" icon="briefcase" href="/enterprise/overview">
    Collaboration, governance, and scale for larger teams.
  </Card>
</CardGroup>

<Note>
  Organization roles are **owner** and **admin**. The Composer, the Assistant, schedules, and knowledge management require owner or admin. The older `member` role has been retired. See [roles and permissions](/security/roles-permissions).
</Note>

## Behaviors to know

A few behaviors are worth knowing before you build — see [Behaviors & edge cases](/reference/known-limitations) for the full list.

<Accordion title="Things to be aware of">
  * **Tool dependencies** install directly — install the base package, then add each tool's SDK.
  * **OAuth credentials**: if a connection expires, reconnect the integration to issue fresh tokens.
  * The **`subscriptions`** resource exists in the Python SDK only, not the JavaScript SDK.

  See [Behaviors & edge cases](/reference/known-limitations) for the full list.
</Accordion>

## The feature matrix at a glance

One table, every area. Use it to find the page that goes deep.

| Area                     | What it does                                          | Where to use it                                                        |
| ------------------------ | ----------------------------------------------------- | ---------------------------------------------------------------------- |
| Workflow builder         | Build workflows on a visual canvas                    | [Builder overview](/workflow-builder/overview)                         |
| Node types (9)           | The building blocks of every workflow                 | [Node types overview](/workflow-builder/nodes/overview)                |
| Variables and references | Pass data between steps                               | [Variables and references](/workflow-builder/variables-and-references) |
| Execution and deploy     | Run, deploy, schedule, expose as an API               | [Running workflows](/workflow-builder/execution/running)               |
| AI Composer              | Turn a prompt into an editable workflow               | [AI Composer](/concepts/ai-composer)                                   |
| Assistant                | Agentic chat that uses your tools                     | [Assistant overview](/assistant/overview)                              |
| Human-in-the-loop        | Pause a run for human input or approval               | [HITL resume](/realtime/hitl)                                          |
| Knowledge and RAG        | Answer from your own documents                        | [Knowledge and RAG](/concepts/knowledge-rag)                           |
| Knowledge providers      | Managed storage or bring your own vector store        | [Knowledge providers](/integrations/knowledge-providers/overview)      |
| Chat                     | Talk to the Assistant, run workflows, query knowledge | [Chat overview](/platform/chat/overview)                               |
| Integrations (175)       | Connect services and call their actions               | [Integrations overview](/integrations/overview)                        |
| LLM providers            | Managed models or bring your own key                  | [LLM providers](/integrations/llm-providers/overview)                  |
| Building integrations    | Author your own tools and connectors                  | [Build an integration](/integrations/building/overview)                |
| Realtime collaboration   | Co-edit the canvas live with your team                | [Realtime model](/concepts/realtime-model)                             |
| Presence and locks       | See who is editing and avoid conflicts                | [Presence, locks and versioning](/realtime/presence-locks)             |
| Credits and billing      | Meter managed usage, manage the wallet                | [Billing overview](/billing/overview)                                  |
| Plans and pricing        | Free, Pro, Max, Enterprise                            | [Plans and pricing](/billing/plans)                                    |
| REST API                 | Run everything from code                              | [API overview](/api-reference/overview)                                |
| SDKs                     | JavaScript and Python clients                         | [SDKs overview](/sdks/overview)                                        |
| Streaming (SSE)          | Stream run events live                                | [SSE run streaming](/realtime/sse-streaming)                           |
| Organizations and roles  | Multi-tenant access control                           | [Organizations, roles and membership](/concepts/organizations-roles)   |
| Security and encryption  | Protect credentials and data                          | [Security overview](/security/overview)                                |
| Enterprise               | SSO, deployment, and scale                            | [ModuleX for enterprise](/enterprise/overview)                         |

## Where to go next

<CardGroup cols={3}>
  <Card title="How ModuleX works" icon="circle-info" href="/concepts/overview">
    The end-to-end mental model behind every feature here.
  </Card>

  <Card title="Recipes" icon="list-check" href="/power-using/recipes">
    Reusable patterns that combine features to solve real problems.
  </Card>

  <Card title="Optimization" icon="gauge-high" href="/power-using/optimization">
    Tune workflows and usage for speed, reliability, and cost.
  </Card>
</CardGroup>
