> ## Documentation Index
> Fetch the complete documentation index at: https://dragonwingdocs-staging.qualcomm.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Application development with QIM SDK

> Understand the important QIM SDK components for an AI application and follow the application development workflow from use case to a built application.

Developing an AI application with QIM SDK consists of two steps: understanding the core components of the AI pipeline and following the application development workflow to integrate, configure, and deploy your application.

<CardGroup cols={2}>
  <Card title="Important components" icon="cubes" href="#important-qim-sdk-components-for-an-ai-application">
    The four plugins every AI pipeline is built from, and which one usually blocks integration.
  </Card>

  <Card title="Development workflow" icon="route" href="#application-development-workflow">
    Use case → AI Hub model check → post-processing check → build the application.
  </Card>

  <Card title="Post-processing modules" icon="sliders" href="#post-processing-modules-and-supported-use-cases">
    Supported use cases, model families, and the metadata each module type produces.
  </Card>
</CardGroup>

## Important QIM SDK components for an AI application

Every QIM SDK AI application is assembled from a small set of components. Two of them decide whether your use case works out of the box: the **inference plugin** that runs your model, and the **post-processing module** that turns raw output tensors into usable metadata.

| Component | Plugin | What it does | Why it is important |
| - | - | - | - |
| AI preprocessing | [`qtimlvconverter`](https://imsdkdocs.qualcomm.com/plugin-reference/qtimlvconverter) | Resize, color conversion, and tensor-layout transformation on the GPU. | Produces the exact tensor your model expects, without making the CPU the bottleneck. |
| AI inference | [`qtimltflite`](https://imsdkdocs.qualcomm.com/plugin-reference/qtimltflite) · [`qtimlqnn`](https://imsdkdocs.qualcomm.com/plugin-reference/qtimlqnn) · [`qtimlsnpe`](https://imsdkdocs.qualcomm.com/plugin-reference/qtimlsnpe) | Runs the model and returns raw output tensors. | Selects the Qualcomm acceleration path — LiteRT/TFLite delegate, Qualcomm AI Engine Direct/QNN, or SNPE. Your model format decides which plugin you use. |
| **Post-processing** | [`qtimlpostprocess`](https://imsdkdocs.qualcomm.com/plugin-reference/qtimlpostprocess) | Loads a module that decodes output tensors into ML metadata — labels, boxes, masks, keypoints. | **If no module matches your model's output, the pipeline produces no usable results.** This is the most common integration blocker. |
| Metadata consumption | [`qtivoverlay`](https://imsdkdocs.qualcomm.com/plugin-reference/qtivoverlay) · application logic | Draws metadata on the frame with GPU acceleration, or hands it to your code. | Turns detections into what the product actually does: visualization, events, analytics, or control logic. |

<Warning>
  Post-processing is model-specific, not use-case-generic. Two object detectors can require different decode logic. Confirm a module exists for **your exact model output** before you plan the build — see [Post-processing modules and supported use cases](#post-processing-modules-and-supported-use-cases).
</Warning>

<Tip>
  To list the QIM SDK plugins on your device, and inspect the post-processing modules and tensor shapes each one accepts:

  ```shell theme={null}
  gst-inspect-1.0 | grep qti
  ```

  ```shell theme={null}
  gst-inspect-1.0 qtimlpostprocess
  ```
</Tip>

## Application development workflow

The workflow is driven by two decisions: **whether a compatible model is available on Qualcomm AI Hub** and **whether an existing post-processing module supports the model output**. If both are supported, proceed directly to application development. Otherwise, integrate your own model and/or add a custom post-processing module first.

```mermaid theme={null}
%%{init: {"themeVariables": {"fontSize": "13px"}, "flowchart": {"htmlLabels": true, "nodeSpacing": 18, "rankSpacing": 30, "curve": "basis", "padding": 6}}}%%
flowchart LR
    UC["1 · Select<br/>the use case"]
    Q1{"2 · Model on<br/>AI Hub?"}
    BYOM["2a · Bring your<br/>own model"]
    Q2{"3 · Post-processing<br/>supported?"}
    ADD["3a · Add post-processing<br/>module"]
    BUILD["4 · Build the<br/>application"]

    UC --> Q1
    Q1 -->|"Yes"| Q2
    Q1 -->|"No"| BYOM --> Q2
    Q2 -->|"Yes"| BUILD
    Q2 -->|"No"| ADD --> BUILD

    classDef step fill:#31017D,stroke:#31017D,color:#ffffff;
    classDef fork fill:#3253DC,stroke:#3253DC,color:#ffffff;
    classDef decision fill:#ffffff,stroke:#31017D,color:#31017D;
    class UC,BUILD step;
    class BYOM,ADD fork;
    class Q1,Q2 decision;
```

| Step | What you do | Where to go |
| - | - | - |
| 1 | **Select the use case.** Decide what the application must detect, classify, segment, or enhance, and note the required resolution and frame rate. | [Supported use cases](#post-processing-modules-and-supported-use-cases) |
| 2 | **Check if the model is available on Qualcomm AI Hub.** If a suitable pre-optimized model exists, download it for your device and runtime. | [Qualcomm AI Hub](../topic/ai-hub) |
| 2a | **Bring your own model** — only if no AI Hub model fits. Train or source the model, then compile and quantize it for the target. | [Integrating a custom AI model](../topic/integrate-custom-model) |
| 3 | **Check if post-processing is supported in QIM SDK.** Compare your model's output tensors with the available `qtimlpostprocess` modules. | [Post-processing modules](#post-processing-modules-and-supported-use-cases) |
| 3a | **Add post-processing support** — only if no module matches. Write, build, and deploy a custom module. | [Add post-processing support](../topic/add-postprocessing-support-custom-model) |
| 4 | **Build the application.** Choose a development path, validate the pipeline, then build with GStreamer, C++, or Python App Builder. | [Build the application](../topic/imsdk-build-application) |

<Note>
  Steps 2a and 3a are optional. When a suitable AI Hub model and a compatible post-processing module are available, you can move directly from defining the use case to building the application.
</Note>

## Post-processing modules and supported use cases

The `qtimlpostprocess` plugin converts raw model output tensors into structured metadata that can be consumed by the rest of the pipeline. Configure the required post-processing module using the `module` property and provide any model-specific `labels` or `settings` needed by that module. **Selecting a module that matches your model's output is the single most important decision for whether the pipeline produces usable results.**

| Module type | Example model families | Raw model output | Metadata produced for downstream stages |
| - | - | - | - |
| `image-classification` | MobileNet and similar classifiers | Confidence scores per class | Top labels and scores, filtered by confidence threshold |
| `object-detection` | SSD-MobileNet, YOLOv5, YOLO-NAS, YOLOv8 | Box coordinates, class IDs, scores | Decoded bounding boxes, mapped labels, and filtered confidence scores |
| `image-segmentation` | DeepLabV3, FFNet | Pixel-level class maps or depth tensors | Segmentation masks aligned with the source frame |
| `pose-estimation` | PoseNet MobileNet and similar keypoint models | Keypoint coordinates and confidences | Keypoints plus the links between them, ready to render or track |
| `super-resolution` | QuickSRNet, XLSR | Enhanced image tensors | Higher-resolution frames or tensors for the output stage |
| `audio-classification` | YAMNet and similar audio models | Audio class probabilities | Class labels and confidence scores |
| Raw tensor or custom output | Any model whose output no module matches | Model-specific tensor data | **Nothing, until you provide a matching module** — see [Add post-processing support](../topic/add-postprocessing-support-custom-model) |

<Note>
  The examples shown are representative model families rather than an exhaustive list. Since post-processing modules are generally based on output tensor formats, many compatible models can reuse the same module. Verify your model's output tensors against the supported formats reported by `gst-inspect-1.0 qtimlpostprocess` before deciding that a custom module is required.
</Note>

<Warning>
  If your model falls into the **raw tensor or custom output** row, the pipeline will not produce usable metadata until a matching module exists. Plan for this before integration rather than during bring-up.
</Warning>

## Next steps

Pick the card that matches where you are in the workflow.

<CardGroup cols={3}>
  <Card title="Bring your own model" icon="puzzle-piece" href="../topic/integrate-custom-model">
    **Step 2a** — no AI Hub model fits, so compile and quantize your own for the target.
  </Card>

  <Card title="Add post-processing support" icon="sliders" href="../topic/add-postprocessing-support-custom-model">
    **Step 3a** — no built-in module matches your output, so write and deploy a custom module.
  </Card>

  <Card title="Build the application" icon="hammer" href="../topic/imsdk-build-application">
    **Step 4** — model and module are ready, so choose a path and build.
  </Card>
</CardGroup>

<Tip>
  Run the post-processing check (step 3) before you invest in module development. If an existing module already accepts your model's output tensors, you skip step 3a entirely.
</Tip>

## Related information

* [Qualcomm AI Hub](../topic/ai-hub) — download pre-trained, optimized models to use in these pipelines.
* [Plugin reference](https://imsdkdocs.qualcomm.com/plugin-reference/introduction) — every QIM SDK plugin, with properties and caps.
* [Sample pipelines](https://imsdkdocs.qualcomm.com/sample-pipelines/aipipelines) — ready-to-run pipelines for each use case.