API Generation

type Query {
  classifyText(text: String!, threshold: Float!): String!
}

package main

import (
  "errors"
  "fmt"
  "github.com/hypermodeinc/modus/sdk/go/models"
  "github.com/hypermodeinc/modus/sdk/go/models/experimental"
)

const modelName = "my-classifier"

// this function takes input text and a probability threshold, and returns the
// classification label determined by the model, if the confidence is above the
// threshold; otherwise, it returns an empty string

func ClassifyText(text string, threshold float32) (string, error) {
  predictions, err:= classify(text)
  if err != nil {
    return "", err
  }

  prediction := predictions[0]
  if prediction.Confidence < threshold {
    return "", nil
  }

  return prediction.Label, nil
}

func classify(texts ...string) ([]experimental.ClassifierResult, error) {
  model, err := models.GetModel[experimental.ClassificationModel](modelName)
  if err != nil {
    return nil, err
  }

  input, err := model.CreateInput(texts...)
  if err != nil {
    return nil, err
  }

  output, err := model.Invoke(input)
  if err != nil {
    return nil, err
  }

  if len(output.Predictions) != len(texts) {
    word := "prediction"
    if len(texts) > 1 {
      word += "s"
    }

    return nil, fmt.Errorf("expected %d %s, got %d", len(texts), word, len(output.Predictions))
  }

  return output.Predictions, nil
}

type Query {
  classifyText(text: String!, threshold: Float!): String!
}

import { models } from "@hypermode/modus-sdk-as"
import {
  ClassificationModel,
  ClassifierResult,
} from "@hypermode/modus-sdk-as/models/experimental/classification"

const modelName: string = "my-classifier"

// this function takes input text and a probability threshold, and returns the
// classification label determined by the model, if the confidence is above the
// threshold; otherwise, it returns an empty string
export function classifyText(text: string, threshold: f32): string {
  const predictions = classify(text, threshold)

  const prediction = predictions[0]
  if (prediction.confidence < threshold) {
    return ""
  }

  return prediction.label
}

function classify(text: string, threshold: f32): ClassifierResult[] {
  const model = models.getModel<ClassificationModel>(modelName)
  const input = model.createInput([text])
  const output = model.invoke(input)

  return output.predictions
}