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

> ## Agent Instructions
> Choose User guide for browser tasks, Developers for CLI, SDK and external agents, and Administration for organization management.
> Confirm identity and organization/project context before operations. Documentation access does not grant ThinkPlatform permissions.
> Review side effects, verify changes with a read, and do not blindly retry an operation with an uncertain outcome.
> Use documented UI steps for the web app and documented public CLI or SDK interfaces for automation. Follow each page’s prerequisites and authentication requirements.

# Integration and flow commands

> Discover modules, configure flows, and connect event-driven integrations.

These examples assume an authenticated active saved profile with the intended organization and project. Confirm it with `tp context show` before running commands. Add root `--json` before the command when machine parsing needs JSON output; use root `--profile <name>` only to override the active profile.

## Check context and discover resources

```bash theme={"system"}
tp auth whoami
tp context show
tp modules list
tp flows list
tp hooks list
tp webhooks list
tp api operations
```

## Modules

```bash theme={"system"}
tp modules list
tp modules get <module_id>
tp modules invoke <module_id> --tool <tool_name> --input @payload.json
```

Python SDK pattern for multi-step logic:

```python theme={"system"}
from thinkplatform.sdk import client_from_env

tp = client_from_env()
result = tp.modules.invoke(
    "<module_id>",
    "<tool_name>",
    input_data={"query": "status"},
).result
print(result)
```

## Flows

```bash theme={"system"}
tp flows create --name "Example flow" --body @flow.json --dry-run
tp flows create --name "Example flow" --body @flow.json
tp flows save <flow_id> --data @flow-data.json --dry-run
tp flows save <flow_id> --data @flow-data.json
tp flows run <flow_id> --input @input.json
```

Use Code Flow for arbitrary Python backend logic and graph Flow for inspectable orchestration.

## API fallback

Discover before calling raw routes:

```bash theme={"system"}
tp api operations --tag "<tag>"
tp api show <operation_id>
tp api call <operation_id> --body @payload.json
tp rest GET /api/...
tp rest POST /api/... --body @payload.json
tp raw get /api/...
tp raw post /api/... --body @payload.json
```

## Event integration

```bash theme={"system"}
tp automation hooks create --body @hook.json --dry-run
tp automation hooks invoke <hook_id> --body @sample-event.json
tp automation hooks deliveries <hook_id>

tp automation webhooks event-types
tp automation webhooks create --body @webhook.json --dry-run
tp automation webhooks test <subscription_id> --body @event.json
tp automation webhooks deliveries <subscription_id>
```

## Verification checklist

* Read schemas/tool definitions before payload creation.
* Check that sample inputs and outputs match the expected structure.
* Run one controlled invocation.
* Inspect Flow run, hook delivery, webhook delivery, or Module result.
* Record exact payload file and resource IDs for repeatability.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.