Using AI In Apex

You're an Apex expert with deep Salesforce product knowledge.
Write an Apex class that takes in a string and returns a list of strings categorizing the input string.
For example, if I passed in the string "A man, a plan, a canal",
I might get back a list of strings like this: [ "palindrome", "humor"].
As another example, if I passed in:
  "I bought the United swivel chair off of your website and it broke immediately after I put it together.
   Putting it together was also difficult",
I might get back a list of strings like this:
[ "customer complaint", "setup problems"].

public class StringCategorizer {

  public static List<String> categorizeString(String input) {
    List<String> categories = new List<String>();

    // Check for palindrome
    String cleanInput = input.replaceAll('[^A-Za-z0-9]', '').toLowerCase();
    String reversedInput = cleanInput.reverse();
    if (cleanInput == reversedInput) {
      categories.add('palindrome');
    }

    // Check for humor
    if (input.containsIgnoreCase('a man, a plan, a canal')) {
      categories.add('humor');
    }

    // Check for customer complaint
    if (input.toLowerCase().contains('broke') || input.toLowerCase().contains('not working')) {
      categories.add('customer complaint');
    }

    // Check for setup problems
    if (input.toLowerCase().contains('difficult to put together') || input.toLowerCase().contains('setup problems')) {
      categories.add('setup problems');
    }

    // Add more categories based on different patterns or keywords as needed

    return categories;
  }
}

Categorize the following:

- "I was walking down the street when I saw a charming restaurant on the corner.
  The intriguing facade inspired me, and I went in to taste their wares.
  To my very great surprise, this was no pinnacle of culinary delight!"
- "Push versus pull architecture each come with their own pros and cons.
  Pull architecture is less resource-intensive, assuming that pulls are not being made constantly, since each request contains only a single subscriber;
  push architecture allows for instant notifications to be made, at the cost of having to notify all potential subscribers."
- "It's long been noted that fashion follows definitive cycles,
  and may even be the originating point for the phrase 'everything old is new again.'
  Look at the rise of bell-bottomed jeans, which last saw prevalance in the 1990s, and in the 1960s before that."

Your response should be in JSON, like such:
{ "data":
  [
    { "input": "I was walking down the street when I saw a charming restaurant on the corner.
        The intriguing facade inspired me, and I went in to taste their wares.
        To my very great surprise, this was no pinnacle of culinary delight!",
      "categories": [ "negative review"]
    },
    { "input": "Push versus pull architecture each come with their own pros and cons.
        Pull architecture is less resource-intensive, assuming that pulls are not being made constantly, since each request contains only a single subscriber;
        push architecture allows for instant notifications to be made, at the cost of having to notify all potential subscribers.",
      categories: [ "software architecture", "push", "pull", "queues"]
    },
    { input: "It's long been noted that fashion follows definitive cycles,
        and may even be the originating point for the phrase 'everything old is new again.'
        Look at the rise of bell-bottomed jeans, which last saw prevalance in the 1990s, and in the 1960s before that.",
      categories: [ "fashion", "cyclical history"]
    }
  ]
}

{
  "data": [
    {
      "input": "I was walking down the street when I saw a charming restaurant on the corner. The intriguing facade inspired me, and I went in to taste their wares. To my very great surprise, this was no pinnacle of culinary delight!",
      "categories": ["negative review", "personal narrative"]
    },
    {
      "input": "Push versus pull architecture each come with their own pros and cons. Pull architecture is less resource-intensive, assuming that pulls are not being made constantly, since each request contains only a single subscriber; push architecture allows for instant notifications to be made, at the cost of having to notify all potential subscribers.",
      "categories": [
        "software architecture",
        "push",
        "pull",
        "resource management"
      ]
    },
    {
      "input": "It's long been noted that fashion follows definitive cycles, and may even be the originating point for the phrase 'everything old is new again.' Look at the rise of bell-bottomed jeans, which last saw prevalence in the 1990s, and in the 1960s before that.",
      "categories": ["fashion", "cyclical trends", "historical analysis"]
    }
  ]
}

public class StringCategorizer {
  private static final String PROMPT = 'Categorize the text in the To Be Categorized section below. Respond using JSON with an object like such: { "data": [{ "input": "the text from the To Be Categorized Section below", "categories": ["a category the text fits into", "another category"]}]}. As an example, if the To Be Categorized section contains the text "row row row your boat gently down the stream..." the response should be something like: {"data": ["input": "row row row your boat gently down the stream...", categories: ["nursery rhymes"]}]}\n\n##To Be Categorized\n\n{0}'

  public static List<Category> categorizeString(String input) {
    // getResponseFromLLM is not shown - more on that later
    String responseBody = getResponseFromLLM(String.format(PROMPT, new List<String>{ input }));
    CategoryResponse response;
    try {
      response = (CategoryResponse) JSON.deserialize(responseBody, CategoryResponse.class);
    } catch (Exception ex) {
      // we do love using Nebula Logger...
      Logger.warn('Error deserializing', ex);
      Logger.saveLog();
      response = new CategoryResponse();
      response.isSuccess = false;
    }

    if (response.isSuccess) {
      return response.data;
    } else {
      // if there isn't something valid to do here, you can simply use Logger.exception(ex); above to save the log
      // and throw the exception automatically
    }
  }


  private class CategoryResponse {
    public List<Category> data;
    public Boolean isSuccess = true;
  }

  public class Category {
    public String input;
    public List<String> categories;
  }
}

Certainly! Here's your response:

```json
{
  "data": [
    {
      "input": "I was walking down the street when I saw a charming restaurant on the corner. The intriguing facade inspired me, and I went in to taste their wares. To my very great surprise, this was no pinnacle of culinary delight!",
      "categories": ["negative review", "personal narrative"]
    },
    {
      "input": "Push versus pull architecture each come with their own pros and cons. Pull architecture is less resource-intensive, assuming that pulls are not being made constantly, since each request contains only a single subscriber; push architecture allows for instant notifications to be made, at the cost of having to notify all potential subscribers.",
      "categories": [
        "software architecture",
        "push",
        "pull",
        "resource management"
      ]
    },
    {
      "input": "It's long been noted that fashion follows definitive cycles, and may even be the originating point for the phrase 'everything old is new again.' Look at the rise of bell-bottomed jeans, which last saw prevalence in the 1990s, and in the 1960s before that.",
      "categories": ["fashion", "cyclical trends", "historical analysis"]
    }
  ]
}
```

aiplatform.ModelsAPI.createGenerations_Request request = new aiplatform.ModelsAPI.createGenerations_Request();
request.modelName = 'sfdc_ai__DefaultOpenAIGPT4Omni';
request.body = new aiplatform.ModelsAPI_GenerationRequest();
request.body.prompt = 'Categorize the following data" ["apples", "bananas", "screws", 1]';

aiplatform.ModelsAPI.createGenerations_Response response = new aiplatform.ModelsAPI().createGenerations(request);
Logger.debug(response.Code200.generation.generatedText);
/** The response without any mention of JSON in the prompt:
 * Certainly! The data can be categorized as follows:

1. **Fruits**:
   - Apples
   - Bananas

2. **Hardware**:
   - Screws

3. **Numbers**:
   - 1
 * */
Logger.saveLog();

public class EinsteinRequest {
  public String prompt;
  public String model;
  // this object can be expanded upon
  // as needed as additional properties - like response tokens -
  // need to be configured
}

public virtual class LLM {
  public virtual String getGeneration(EinsteinRequest request) {
    aiplatform.ModelsAPI.createGenerations_Request request = new aiplatform.ModelsAPI.createGenerations_Request();
    request.modelName = request.model;
    request.body = new aiplatform.ModelsAPI_GenerationRequest();
    request.body.prompt = request.prompt;

    aiplatform.ModelsAPI.createGenerations_Response response = new aiplatform.ModelsAPI().createGenerations(request);
    // response also has a response.responseCode property, so error handling can be done
    return response.Code200.generation.generatedText;
  }
}

public class Factory {
  @TestVisible
  private static factory;

  public static Factory getFactory() {
    return factory ?? new Factory();
  }

  public virtual LLM getLLM() {
    return new LLM();
  }

  public Example getExample() {
    // see below
    return new Example(this);
  }
}

// and then in a test class:
private static final LLMMock mock = new LLMMock();
public class EinsteinFactory extends Factory {
  public override LLM getLLM() {
    return mock;
  }
}

public class LLMMock extends LLM {
  public EinsteinRequest lastRequest;
  public String response = 'Some response';

  public override String getGeneration(EinsteinRequest request) {
    this.lastRequest = request;
    return this.response;
  }
}

// in the actual production level code:

public class Example {
  private final LLM llm;

  public Example(Factory factory) {
    this.llm = factory.getLLM();
  }

  public String categorize() {
    EinsteinRequest req = new EinsteinRequest();
    req.prompt = 'Categorize the following data" ["apples", "bananas", "screws", 1]';
    req.model = 'sfdc_ai__DefaultOpenAIGPT4Omni';
    return this.llm.getGeneration(req);
  }
}

// and back in the test

@IsTest
static void passesCorrectParamtersToLLM() {
  // arrange
  Factory.factory = new EinsteinFactory();
  mock.response = 'Something you\'d expect to get back from Einstein';

  // act
  String categorizationResponse = Factory.getFactory().getExample().categorize();

  // assert
  Assert.areEqual(mock.response, categorizationResponse);
  Assert.areEqual('sfdc_ai__DefaultOpenAIGPT4Omni', mock.lastRequest.model);
  Assert.areEqual('Categorize the following data" ["apples", "bananas", "screws", 1]', mock.lastRequest.prompt);
}