Supercharge Your Java Application with Generative AI

The introduction of Generative AI has been revolutionary, pushing the envelope of what is possible. For example, one can find a solution to a problem by prompting a large language model, translate different languages without a translator, or create professional-grade drawings without knowing how to draw or enlisting the help of a professional artist.

We will use this library, which contains the client call OpenAI’s api and the related GraphQL schema and data objects. In this article we will demonstrate how to setup your Java Application so you can call OpenAi’s api and expose these calls via GraphiQL (GraphQL’s builtin UI).

by Yi leng Yao

Requirements

• OPENAI_API_KEY

Setting Up Your OpenAI API?Key

• Create an OpenAI Account: If you don’t have an OpenAI account, sign up here.
• Manage OpenAI Credits: If your OpenAI credits are depleted or expired, set up your billing methods here.
• Set Usage Limits: To prevent unexpected charges, configure your Hard and Soft usage limits here.
• Generate Your API Key: Create your API key here, save this key securely.
• Set Up the API Key as an Environment Variable: Use the following command to set your API key as an environment variable:

export OPENAI_API_KEY="your api-key"        

Your Spring Boot application will retrieve the OpenAI Api key from the environment variable, and use the api key to call OpenAI’s API.

(Optional) Creating Spring Boot?Project

If you already have your own Java application, you can skip this step. However, for those who don’t:

• Read the following Guide on setting up “Your Spring Boot Application With GitHub Actions”

• Or you can clone openai-application an run

./mvnw spring-boot:run        

Setting up your Spring Boot?Project

Adding Dependencies

You will need to add the following dependencies to your pom.xml

<!-- openai client dependency -->
<dependency>
    <groupId>io.github.yilengyao</groupId>
    <artifactId>openai</artifactId>
    <version>1.0.0</version>
</dependency>

<!-- graphql dependency -->
<dependency>
    <groupId>com.netflix.graphql.dgs</groupId>
    <artifactId>graphql-dgs-spring-boot-starter</artifactId>
    <version>7.3.6</version>
</dependency>

<dependency>
    <groupId>com.graphql-java</groupId>
    <artifactId>graphql-java-extended-scalars</artifactId>
    <version>20.0</version>
 </dependency>

 <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
 </dependency>        

Compatibility Note:

• If your spring-boot-starter-parent version is 3.x.x or later, you must use graphql-dgs-spring-boot-starter version 6.x.x or later. This setup also requires JDK 17.
• For spring-boot-starter-parent version 2.7.x, opt for graphql-dgs-spring-boot-starter version 5.5.x.
• If your application runs on Spring Boot 2.6, you should use graphql-dgs-spring-boot-starter version 5.4.x or earlier.

Then run maven package to download the dependency

./mvnw clean package        

Setting Up GraphQL Datafetcher in Your Spring Boot Application

To integrate GraphQL with your Spring Boot application, you’ll create a Datafetcher component. This component will interact with your OpenAI client and fetch data as required.

• Create the folder graphql in your project and inside the graphql folder create a file named ApplicationSpecificSpringComponentScanMarker.java. This interface acts as a marker for Spring component scanning:

public interface ApplicationSpecificSpringComponentScanMarker {
}        

• Within the graphql folder, add another file named OpenAiDataFetcher.java. This file will contain the actual data fetching logic, which will interface with the OpenAI client:

import com.netflix.graphql.dgs.DgsComponent;
import io.github.yilengyao.openai.client.OpenAiClient;

@DgsComponent
public class OpenAiDataFetcher {

  private final OpenAiClient openAiClient;

  @Autowired
  public OpenAiDataFetcher(OpenAiClient openAiClient) {
    this.openAiClient = openAiClient;
  }

}        

Configuring Your Application to Scan Datafetcher Class and OpenAI-Java Package

Here’s how you can set up the application to scan for the OpenAiDataFetcher class and the classes within the io.github.yilengyao.openai.configuration package:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(
  scanBasePackageClasses = {
    io.github.yilengyao.openai.configuration.ApplicationSpecificSpringComponentScanMarker.class,
    <your package>.graphql.ApplicationSpecificSpringComponent
  }
)
public class <Main-Class-Name> {
    public static void main(String[] args) {
        SpringApplication.run(<Main-Class-Name>.class, args);
    }
};        

Spring’s Stereotype Annotations and Package Scanning:

When you configure Spring to scan specific packages, it looks for classes within those packages that have Stereotype Annotations. For our setup:

• Spring will inspect the io.github.yilengyao.openai.configuration package.
• Within this package, it will identify classes adorned with Stereotype Annotations such as @Component, @Service, and @Controller.

The presence of these Stereotype Annotations signals to Spring that the class should be managed as a bean, and inject them where needed in your application.

Integrating With OpenAI’s Endpoints

Audio

Create Translation

OpenAI provides an endpoint that can translate audio content of another language into English. Here’s how to integrate this functionality into your Spring Boot application using GraphQL:

• Update the OpenAiDataFetcher Class: In the OpenAiDataFetcher class, add the following method:

@DgsMutation
  public TextResponse createTranslation(
      @InputArgument("file") MultipartFile file,
      @InputArgument("translationInput") TranslationInput translationInput) throws IOException {
    return openAiClient.createTranslation(TranslationPayload.fromGraphQl(file, translationInput))
        .toGraphQl();
  }        

• Update the file upload size limit by adding the following to the application.properties file.

spring.servlet.multipart.max-file-size=25MB
spring.servlet.multipart.max-request-size=25MB        

MultipartFile is Spring framework’s representation of an unloaded file. By default maximum upload size is 1MB. Since OpenAI currently supports maximum file size upload of 25MB, we update the MultipartFile size limit to 25MB.

You can launch your Spring Boot by executing the following command in your terminal.

./mvnw spring-boot:run        

Now we can call the translation endpoint using GraphQL:

• Install the Altair GraphQL Chrome extension
• Launch Altair UI.
• For the endpoint, input: https://localhost:8080/graphql.
• Ensure the request method is set to POST
• Use the following GraphQL mutation to initiate the translation:

mutation CreateTranslation($file: Upload!) {
  createTranslation(
    file: $file,
    translationInput: {
      model: "whisper-1",
      prompt: "translate to english"
    }
  ) {
    text
  }
}        

Uploading the Audio File:

• Locate the ellipsis (...) next to Upload and click on it.
• Choose an audio file from your device. OpenAI only support formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.

Handling CSRF Prevention Header?Error:

If you encounter a CSRF prevention header error in Altair

expecting a csrf prevention header but none was found, supported headers are [apollo-require-preflight, x-apollo-operation-name, graphql-require-preflight        

follow these steps:

1. In Altair’s Headers section, add a new header: apollo-require-preflight.
2. Set its value to true.

Create Transcription

OpenAI provides an endpoint that can transcribe audio content into text based on the input language. Here’s how to integrate this functionality into your Spring Boot application using GraphQL:

• Update the OpenAiDataFetcher Class: In the OpenAiDataFetcher class, add the following method:

 @DgsMutation
  public TextResponse createTranscription(
      @InputArgument("file") MultipartFile file,
      @InputArgument("transcriptionInput") TranscriptionInput transcriptionInput) throws IOException {
    return openAiClient.createTranscription(TranscriptionPayload.fromGraphQl(file, transcriptionInput))
        .toGraphQl();
  }        

You can launch your Spring Boot by executing the following command in your terminal.

./mvnw spring-boot:run        

Now we can call the transcription endpoint using GraphQL:

• Launch Altair UI.
• For the endpoint, input: https://localhost:8080/graphql.
• Ensure the request method is set to POST
• Use the following GraphQL mutation to initiate the transcription:

mutation CreateTranscription($file: Upload!) {
  createTranscription(file: $file, 
    transcriptionInput: {
      model: "whisper-1",
      prompt: "Optional prompt text here",
      language: "en"           # Optional language code
  }) {
    text
  }
}        

Uploading the Audio File:

• Locate the ellipsis (...) next to Upload and click on it.
• Choose an audio file from your device. OpenAI only support formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.

Models

OpenAI offers an endpoint to list and describe the various models available. Here’s how to integrate this functionality into your Spring Boot application using GraphQL:

• Update the OpenAiDataFetcher Class: In the OpenAiDataFetcher class, add the following method:

  @DgsQuery
  public ModelsOutput models(
      @InputArgument("id") Optional<String> id) {
    return id.isPresent()
        ? openAiClient.models(id.get()).toGraphQl()
        : openAiClient.models().toGraphQl();
  }        

You can launch your Spring Boot by executing the following command in your terminal.

./mvnw spring-boot:run        

Then go to https://localhost:8080/graphiql

Listing Modes using?GraphiQL

• Accessing the GraphQL UI: Navigate to https://localhost:8080/graphiql to access the GraphQL interface.
• Listing Models: To view the available models use the following GraphQL query:

query AllModels {
  models {
    ... on OpenAiResponse {
      data {
        id
        object
        created
        ownedBy
        permission {
          id
          object
          created
          allowCreateEngine
          allowSampling
          allowLogProbs
          allowSearchIndices
          allowView
          allowFineTuning
          organization
          group
          isBlocking
        }
        root
        parent
      }
      object
    }
  }
}        

Retrieving a Specific?Model

Retrieves a model instance, providing basic information about the model such as the owner and permission.

• Listing Models: To view the available models use the following GraphQL query

query Model {
  models(id: "babbage") {
    __typename
    ... on Model {
      id
      object
     created
      ownedBy
      permission {
        id
        object
        created
        allowCreateEngine
        allowSampling
        allowLogProbs
        allowSearchIndices
        allowView
        allowFineTuning
        organization
        group
        isBlocking
      }
      root
      parent
    }
  }
}        

Completions

OpenAI’s Completions endpoint provides responses based on given text prompts. Here’s how to integrate this functionality into your Spring Boot application using GraphQL:

• Update the OpenAiDataFetcher Class: In the OpenAiDataFetcher class, add the following method:

  @DgsMutation
  public CompletionOutput completion(
      @InputArgument("completionInput") CompletionInput completionInput) {
    return openAiClient
        .completion(CompletionPayload.fromGraphQl(completionInput))
        .toGraphQl();
  }        

After integrating the necessary dependencies, start your Spring Boot application with:

./mvnw spring-boot:run        

Then go to https://localhost:8080/graphiql

Using GraphQL to Query:

• Accessing the GraphQL Interface: Open your browser and navigate to https://localhost:8080/graphiql.
• Generate a Completion with the following GraphQL mutation:

mutation Completion {
  completion(completionInput: {
    model: "text-davinci-003",
    prompt: "Why are cats so cute?",
    max_tokens: 73,
    temperature: 2,
    top_p: 1,
    n: 4,
    stream: false,
    stop: "\n",
  }) {
    id
    object
    created
    model
    choices {
      text
      index
      logprobs {
        tokens
        token_lobprobs
        top_logprobs {
          key
          value
        }
        text_offset
      }
      finish_reason
    }
    usage {
      prompt_tokens
      completion_tokens
      total_tokens
    }
  }
}        

Chat

OpenAI’s Chat endpoint provides dynamic responses based on text prompts. This can simulate a back-and-forth conversation with the model. Here’s how to incorporate this into your Spring Boot application:

• Updating the OpenAiDataFetcher Class: Integrate the Chat endpoint to your OpenAiDataFetcher class:

 @DgsMutation
  public ChatCompletionResult chatCompletion(
      @InputArgument("chatInput") ChatCompletionInput chatInput) {
    if (chatInput.getStream() != null && chatInput.getStream()) {
      return openAiClient
          .streamChatCompletion(ChatCompletionPayload.fromGraphQl(chatInput))
      .next()
      .map(ChatCompletionChunk::toGraphQl)
      .block();
    } else {
      return openAiClient
          .createChatCompletion(ChatCompletionPayload.fromGraphQl(chatInput))
          .toGraphQl();

    }
  }        

• Launching the Application: Once you’ve appended the required dependencies, fire up your Spring Boot application:

./mvnw spring-boot:run        

Then go to https://localhost:8080/graphiql

Querying with GraphQL:

• Accessing the GraphQL Interface: Launch https://localhost:8080/graphiql in your browser.
• Simulating a Chat: To create a chat completion using your parameters, input the following GraphQL mutation:

  mutation ChatCompletion {
  chatCompletion(chatInput: {
    model: "gpt-3.5-turbo",
    messages: [
      {
        role: "system",
        content: "Who is the greatest woccer player."
      },
      {
        role: "user",
        content: "How bad is Harry Maguire?"
      }
    ],
    stream: false
  }) {
    ... on ChatCompletion {
      id
      object
      create
      model
      choices {
        index
        message {
          role
          content
          function_call {
            name
            arguments
          }
        }
      }
      usage {
        prompt_tokens
        completion_tokens
        total_tokens
      }
    }
    ... on ChatCompletionChunk {
      id
      object
      created
      model
      choices {
        index
        delta {
          role
          content
          function_call {
            name
            arguments
          }
        }
      }
    }
  }
}        

Generating and Editing?Images

OpenAI offers endpoints that allow you to create images from textual prompts and edit existing images.

Create Image?Endpoint

This endpoint allows you creates an image with a prompt.

Here’s how to incorporate this into your Spring Boot application:

• Updating the OpenAiDataFetcher Class: Integrate the Chat endpoint to your OpenAiDataFetcher class:

@DgsMutation
  public ImageResponse createImage(
      @InputArgument("createImageInput") CreateImageInput createImageInput) {
    return openAiClient
        .createImage(CreateImagePayload.fromGraphQl(createImageInput))
        .toGraphQl();
  }        

Running the Application:

After updating dependencies, start your Spring Boot app:

./mvnw spring-boot:run        

Navigate to https://localhost:8080/graphiql and run the following mutation to generate an image:

mutation CreateImage {
  createImage(createImageInput: {
    prompt: "Supercharge you Java Application with Generative AI",
    # responseFormat: B64_JSON,
    n: 5,
    size: X256
  }) {
    createdAt
    data {
      url
      b64Json
    }
  }
}        

Edit Images

This endpoint allows you to edit an existing image and a prompt.

Here’s how to incorporate this into your Spring Boot application:

• Updating the OpenAiDataFetcher Class: Integrate the Chat endpoint to your OpenAiDataFetcher class:

To add the Images endpoint, in the OpenAiDataFetcher class add
  @DgsMutation
  public ImageResponse createImage(
      @InputArgument("createImageInput") CreateImageInput createImageInput) {
    return openAiClient
        .createImage(CreateImagePayload.fromGraphQl(createImageInput))
        .toGraphQl();
  }        

Now we can call the edit image endpoint using GraphQL:

• Launch Altair UI.
• For the endpoint, input: https://localhost:8080/graphql.
• Ensure the request method is set to POST
• Use the following GraphQL mutation to edit an image:

mutation EditImage($image: Upload!) {
  editImage(
    image: $image,
    # mask: $mask,
    editImageInput: {
      prompt: "Turn into winter wonderland",
      n: 3,
      size: X512,
      # responseFormat: URL,
      # user: "user"
    }
  ) {
    createdAt,
    data {
      url
      b64Json
    }
  }
}        

Uploading the Image File:

• Locate the ellipsis (...) next to Upload and click on it.
• Choose an image file from your device. The image must be in png format, square, and less than 4MB.

You can read more about the Java library that we use to integrate with OpenAI

Happy Developing! ??.

Related Medium article