voyager-new-app

Create New Application

Create a Python application for Axelera AI hardware using Voyager SDK InferenceStream

Use This Skill When / Not When

• Use when: the user wants a standalone Python app (REST API, alerts, custom UI, multi-stream business logic) around a validated pipeline.
• Not when: they need the initial end-to-end runnable pipeline -- route to voyager-launch and run it first.
• Not when: they only want YAML -- route to voyager-new-pipeline.

Instructions

Create an application with the specified requirements: $ARGUMENTS

If the request is primarily for a complete validated video/demo result, browser popup, or user-facing output viewer, use voyager-launch first. Its launch harness creates and opens viewer/index.html after Metis validation.

Step 0: Data Source & Environment Selection

{{INCLUDE common/voyager-sdk-setup.md}}

Step 0.5: Axelera Voyager Project & Task Integration

{{INCLUDE common/voyager-task-integration.md}}

Step 1: Application Requirements Analysis

• Parse application type from arguments
• If not specified, ask for:
  • Application purpose (monitoring, analytics, demo, production)
  • Model/pipeline to use
  • Input sources (cameras, video files, streams)
  • Output requirements (display, file, API, custom processing)
  • Business logic requirements

Step 2: Application Template Selection

Based on requirements, choose appropriate template:

• Simple Demo: Basic display with inference results
• Analytics: Data collection and metrics
• Monitoring: Multi-stream with alerts
• Custom Processing: Full control over inference results
• REST API: HTTP endpoint for inference

Step 3: Basic Application Structure

Create application file with this structure:

#!/usr/bin/env python
# Copyright <year>
# Application: <description>

from axelera.app import config, create_inference_stream, display

# Configuration
MODEL = "<model-name>"
SOURCES = ["<source1>", "<source2>"]

# Create inference stream
stream = create_inference_stream(
    network=MODEL,
    sources=SOURCES,
)

def process_frame(frame_result):
    """Process a single inference result."""
    image = frame_result.image
    meta = frame_result.meta
    stream_id = frame_result.stream_id

    # Add custom processing here
    pass

def main(window, stream):
    """Main inference loop."""
    for frame_result in stream:
        process_frame(frame_result)
        window.show(frame_result.image, frame_result.meta, frame_result.stream_id)

        if window.is_closed:
            break

# Run application
with display.App(renderer=True) as app:
    wnd = app.create_window("Application Title", (1280, 720))
    app.start_thread(main, (wnd, stream), name='InferenceThread')
    app.run()

stream.stop()