GitHub Issue Triage and Duplicate Detection with Qdrant

id: github-issue-triage-and-duplicate-detection-qdrant
namespace: company.team

inputs:
  - id: embedding_model
    type: STRING
    displayName: Embedding Model
    defaults: "text-embedding-3-small"
    description: OpenAI embedding model used to vectorize issue titles and descriptions.

  - id: chat_model
    type: STRING
    displayName: Chat Classification Model
    defaults: "gpt-4o-mini"
    description: OpenAI chat model used for zero-shot issue categorization when no
      duplicates exist.

  - id: qdrant_collection
    type: STRING
    displayName: Qdrant Collection Name
    defaults: "github-issues"
    description: Qdrant vector collection storing historical issue embeddings and metadata.

  - id: similarity_threshold
    type: FLOAT
    displayName: Similarity Score Threshold
    defaults: 0.82
    description: Minimum cosine similarity score (0.0 to 1.0) to flag an issue as a
      potential duplicate.

  - id: top_k
    type: INT
    displayName: Top Matches Limit
    defaults: 3
    description: Maximum number of nearest duplicate candidates to retrieve from Qdrant.

  - id: allowed_labels
    type: ARRAY
    itemType: STRING
    displayName: Allowed Classification Labels
    defaults:
      - "bug"
      - "feature"
      - "question"
      - "documentation"
    description: Permitted taxonomy of issue labels applied by the classification model.

  - id: slack_channel
    type: STRING
    displayName: Slack Notification Channel
    defaults: "#github-triage"
    description: Destination Slack channel for duplicate detection alerts.

triggers:
  - id: github_issue_webhook
    type: io.kestra.plugin.core.trigger.Webhook
    description: Receives GitHub issue webhook payloads authenticated via secret token.
    key: "{{ secret('GITHUB_WEBHOOK_KEY') }}"

tasks:
  - id: gate_issue_event
    type: io.kestra.plugin.core.flow.If
    description: Gate execution to only process newly opened issues authored by
      human users with non-empty content.
    condition: "{{ trigger.body.action == 'opened' and trigger.body.issue.user.type
      != 'Bot' and (trigger.body.issue.title | default('') | trim != '') }}"
    then:
      - id: create_collection_if_missing
        type: io.kestra.plugin.qdrant.CreateCollection
        description: Ensure the Qdrant vector collection exists with 1536-dimensional
          cosine vectors.
        host: "{{ secret('QDRANT_HOST') }}"
        apiKey: "{{ secret('QDRANT_API_KEY') }}"
        collectionName: "{{ inputs.qdrant_collection }}"
        vectorSize: 1536
        distance: COSINE
        allowFailure: true
        retry:
          type: constant
          interval: PT2S
          maxAttempts: 2

      - id: create_embedding
        type: io.kestra.plugin.core.http.Request
        description: Generate dense vector embedding from issue title and body via
          OpenAI API.
        uri: "https://api.openai.com/v1/embeddings"
        method: POST
        contentType: application/json
        headers:
          Authorization: "Bearer {{ secret('OPENAI_API_KEY') }}"
        body: |
          {
            "model": "{{ inputs.embedding_model }}",
            "input": {{ (trigger.body.issue.title ~ "\n\n" ~ (trigger.body.issue.body | default(""))) | slice(0, 8000) | toJson }}
          }
        retry:
          type: constant
          interval: PT3S
          maxAttempts: 3

      - id: search_similar_issues
        type: io.kestra.plugin.qdrant.Query
        description: Search Qdrant collection for semantically similar issues using
          cosine similarity.
        host: "{{ secret('QDRANT_HOST') }}"
        apiKey: "{{ secret('QDRANT_API_KEY') }}"
        collectionName: "{{ inputs.qdrant_collection }}"
        vector: "{{ fromJson(outputs.create_embedding.body).data[0].embedding }}"
        limit: "{{ inputs.top_k + 1 }}"
        scoreThreshold: "{{ inputs.similarity_threshold }}"
        fetchType: FETCH
        retry:
          type: constant
          interval: PT3S
          maxAttempts: 3

      - id: filter_matches
        type: io.kestra.plugin.core.output.OutputValues
        description: Exclude the current issue number from candidates and count matches.
        values:
          duplicate_candidates: >-
            {{ ({'rows': outputs.search_similar_issues.rows} | jq('[(.rows //
            [])[] | select((.id | tostring) != (\"' ~ trigger.body.issue.number
            ~ '\"))]')) | first | default([]) }}
          has_duplicates: >-
            {{ (({'rows': outputs.search_similar_issues.rows} | jq('[(.rows //
            [])[] | select((.id | tostring) != (\"' ~ trigger.body.issue.number
            ~ '\"))] | length')) | first | number) > 0 }}

      - id: route_triage_decision
        type: io.kestra.plugin.core.flow.Switch
        description: Route action based on whether potential duplicate candidates were
          identified.
        value: "{{ outputs.filter_matches.values.has_duplicates ? 'DUPLICATE_FOUND' :
          'NO_DUPLICATE' }}"
        cases:
          "DUPLICATE_FOUND":
            - id: add_duplicate_label
              type: io.kestra.plugin.core.http.Request
              description: Tag the issue with possible-duplicate label.
              uri: "https://api.github.com/repos/{{ trigger.body.repository.full_name
                }}/issues/{{ trigger.body.issue.number }}/labels"
              method: POST
              contentType: application/json
              headers:
                Authorization: "Bearer {{ secret('GITHUB_TOKEN') }}"
                Accept: application/vnd.github+json
              body: '{"labels": ["possible-duplicate"]}'
              retry:
                type: constant
                interval: PT3S
                maxAttempts: 3

            - id: comment_duplicate_matches
              type: io.kestra.plugin.github.issues.Comment
              description: Post explanatory comment with links and similarity scores of
                matching issues.
              oauthToken: "{{ secret('GITHUB_TOKEN') }}"
              repository: "{{ trigger.body.repository.full_name }}"
              issueNumber: "{{ trigger.body.issue.number }}"
              comment: |
                ### Potential Duplicate Issues Detected

                Our automated triage detected semantically similar existing issues in this repository:

                {% for m in outputs.filter_matches.values.duplicate_candidates %}
                - #{{ m.payload.number }}: [{{ m.payload.title }}]({{ m.payload.url }}) (similarity score: {{ (m.score * 100) | round(1) }}%)
                {% endfor %}

                Please review the matching issues above to verify if your inquiry or defect report is already tracked.
              retry:
                type: constant
                interval: PT3S
                maxAttempts: 3

            - id: notify_slack_duplicate
              type: io.kestra.plugin.slack.notifications.SlackIncomingWebhook
              description: Alert triage channel when a potential duplicate issue is created.
              url: "{{ secret('SLACK_WEBHOOK_URL') }}"
              payload: |
                {
                  "channel": "{{ inputs.slack_channel }}",
                  "text": ":warning: Potential Duplicate Issue Opened: <{{ trigger.body.issue.html_url }}|#{{ trigger.body.issue.number }} {{ trigger.body.issue.title }}>",
                  "attachments": [
                    {
                      "color": "#E2B93B",
                      "title": "Semantic Duplicate Alert",
                      "fields": [
                        {
                          "title": "Repository",
                          "value": "`{{ trigger.body.repository.full_name }}`",
                          "short": true
                        },
                        {
                          "title": "Author",
                          "value": "@{{ trigger.body.issue.user.login }}",
                          "short": true
                        },
                        {
                          "title": "Top Match",
                          "value": "<{{ outputs.filter_matches.values.duplicate_candidates[0].payload.url }}|#{{ outputs.filter_matches.values.duplicate_candidates[0].payload.number }} {{ outputs.filter_matches.values.duplicate_candidates[0].payload.title }}> ({{ (outputs.filter_matches.values.duplicate_candidates[0].score * 100) | round(1) }}%)",
                          "short": false
                        }
                      ]
                    }
                  ]
                }
              retry:
                type: constant
                interval: PT5S
                maxAttempts: 3

          "NO_DUPLICATE":
            - id: classify_issue
              type: io.kestra.plugin.openai.ChatCompletion
              description: Classify unique issue into standard categories using structured
                JSON output.
              apiKey: "{{ secret('OPENAI_API_KEY') }}"
              model: "{{ inputs.chat_model }}"
              messages:
                - role: system
                  content: |
                    You are a software engineering issue triage classifier. Categorize the given issue into exactly one of these allowed labels: {{ inputs.allowed_labels | toJson }}.
                    Return valid JSON strictly matching the requested schema.
                - role: user
                  content: |
                    Title: {{ trigger.body.issue.title }}
                    Body:
                    {{ (trigger.body.issue.body | default("No body provided")) | slice(0, 3000) }}
              jsonResponseSchema: |
                {
                  "type": "object",
                  "properties": {
                    "label": {
                      "type": "string"
                    },
                    "reasoning": {
                      "type": "string"
                    }
                  },
                  "required": ["label", "reasoning"],
                  "additionalProperties": false
                }
              retry:
                type: constant
                interval: PT3S
                maxAttempts: 3

            - id: check_and_apply_classification
              type: io.kestra.plugin.core.flow.If
              description: Validate predicted label against allowed taxonomy before tagging
                GitHub issue.
              condition: "{{ inputs.allowed_labels contains
                fromJson(outputs.classify_issue.choices[0].message.content).lab\
                el }}"
              then:
                - id: apply_category_label
                  type: io.kestra.plugin.core.http.Request
                  description: Apply validated category label to the GitHub issue.
                  uri: "https://api.github.com/repos/{{ trigger.body.repository.full_name
                    }}/issues/{{ trigger.body.issue.number }}/labels"
                  method: POST
                  contentType: application/json
                  headers:
                    Authorization: "Bearer {{ secret('GITHUB_TOKEN') }}"
                    Accept: application/vnd.github+json
                  body: '{"labels": ["{{
                    fromJson(outputs.classify_issue.choices[0].message.content).label
                    }}"]}'
                  retry:
                    type: constant
                    interval: PT3S
                    maxAttempts: 3
              else:
                - id: log_unrecognized_label
                  type: io.kestra.plugin.core.log.Log
                  message: "Predicted label '{{
                    fromJson(outputs.classify_issue.choices[0].message.content)\
                    .label }}' is outside allowed taxonomy {{
                    inputs.allowed_labels }}. Skipping automatic labeling."

      - id: upsert_issue_vector
        type: io.kestra.plugin.qdrant.Upsert
        description: Index current issue embedding and metadata into Qdrant for future
          matching.
        host: "{{ secret('QDRANT_HOST') }}"
        apiKey: "{{ secret('QDRANT_API_KEY') }}"
        collectionName: "{{ inputs.qdrant_collection }}"
        points:
          - id: "{{ trigger.body.issue.number }}"
            vector: "{{ fromJson(outputs.create_embedding.body).data[0].embedding }}"
            payload:
              title: "{{ trigger.body.issue.title }}"
              url: "{{ trigger.body.issue.html_url }}"
              number: "{{ trigger.body.issue.number }}"
              repo: "{{ trigger.body.repository.full_name }}"
        retry:
          type: constant
          interval: PT3S
          maxAttempts: 3
    else:
      - id: log_skipped_event
        type: io.kestra.plugin.core.log.Log
        message: "Skipping event: action='{{ trigger.body.action }}', user_type='{{
          trigger.body.issue.user.type | default('unknown') }}', number={{
          trigger.body.issue.number | default(0) }}."