Java Client Library

You can use detoxio.ai APIs in your Java application using our client libraries. The steps are

1. Add our client libraries in your Java application
2. Create gRPC channel with API key credentials
3. Create PromptService client over gRPC channel
4. Call APIs for prompt generation and evaluation

Add Java Client Libraries

note

This example assumes gradle is used as the package manager

Add following lines to your build.gradle file

implementation('build.buf.gen:detoxio_api_protocolbuffers_java:+')
implementation('build.buf.gen:detoxio_api_grpc_java:+')
implementation('io.grpc:grpc-netty-shaded:+')

Refer to our client libraries index for latest versions of client libraries

tip

It is generally a good idea to enable dependency locking

Fetch the dependencies to verify configuration

./gradlew assemble --write-locks --refresh-dependencies

--refresh-dependencies flag is used to force gradle to fetch the latest dependencies. This is required only when you need to update client library version

Create gRPC Channel

Import necessary packages in your code

import build.buf.gen.dtx.services.prompts.v1.Prompt;
import build.buf.gen.dtx.services.prompts.v1.PromptEvaluationResponse;
import io.grpc.*;

Implement a TokenCredentials class for applying DETOXIO_API_KEY as a gRPC CallCredential

class TokenCredentials extends CallCredentials {
    private static final Metadata.Key<String> AUTHORIZATION_METADATA_KEY =
            Metadata.Key.of("Authorization", ASCII_STRING_MARSHALLER);

    private final String token;

    TokenCredentials(String token) {
        this.token = token;
    }

    @Override
    public void applyRequestMetadata(RequestInfo requestInfo,
      Executor appExecutor, MetadataApplier applier) {
      try {
          Metadata headers = new Metadata();
          headers.put(AUTHORIZATION_METADATA_KEY, this.token);
          applier.apply(headers);
      } catch (Throwable e) {
          applier.fail(Status.UNAUTHENTICATED.withCause(e));
      }
    }
}

Create a composite channel credential with TLS verification and token credentials

ChannelCredentials tlsCredentials = TlsChannelCredentials.newBuilder().build();
CallCredentials tokenCredential = new TokenCredentials(token);

ChannelCredentials compositeCredentials = CompositeChannelCredentials
    .create(tlsCredentials, tokenCredential);

Create the gRPC channel using the credentials

ManagedChannel channel = Grpc.newChannelBuilderForAddress("api.detoxio.ai", 443,
    compositeCredentials).build();

Create Prompt Service Client

Now that we have the gRPC channel setup, we can create the Prompt Service client for calling APIs

import build.buf.gen.dtx.services.prompts.v1.*;

PromptServiceGrpc.PromptServiceBlockingStub client =
    PromptServiceGrpc.newBlockingStub(channel);

Thats it! We can now call APIs as per our API schema

Generate a prompt

PromptGenerationRequest req = PromptGenerationRequest.newBuilder()
    .setCount(1)
    .build();

PromptGenerationResponse res = client.generatePrompts(req);

Evaluate prompt response

PromptResponse promptResponse = PromptResponse.newBuilder()
    .setMessage(LlmChatIo.newBuilder()
            .setRole("assistant")
            .setContent("Example prompt response from LLM model")).build();

PromptEvaluationRequest req = PromptEvaluationRequest.newBuilder()
    .setPrompt(prompt)
    .setModelType(LlmEvaluationModelType.LLM_EVALUATION_MODEL_TYPE_COMPREHENSIVE)
    .addResponses(promptResponse).build();

PromptEvaluationResponse res = client.evaluateModelInteraction(req);