implicit val ec = ExecutionContext.global
  implicit val materializer = Materializer(ActorSystem())

  val service = OpenAIServiceFactory()

  val config = ConfigFactory.load("path_to_my_custom_config")
  val service = OpenAIServiceFactory(config)

  val service = OpenAIServiceFactory(
     apiKey = "your_api_key",
     orgId = Some("your_org_id") // if you have one
  )

  val service = OpenAICoreServiceFactory("http://localhost:8000/v1/")

  val service = OpenAIServiceFactory.forAzureWithApiKey(
    resourceName = "your-resource-name",
    deploymentId = "your-deployment-id", // usually model name such as "gpt-35-turbo"
    apiVersion = "2023-05-15",           // newest version
    apiKey = "your_api_key"
  )

  val service = OpenAIServiceFactory.forAzureWithAccessToken(
    resourceName = "your-resource-name",
    deploymentId = "your-deployment-id", // usually model name such as "gpt-35-turbo"
    apiVersion = "2023-05-15",           // newest version
    accessToken = "your_access_token"
  )

  val service = OpenAICoreServiceStreamedFactory.customInstance("http://localhost:8000/v1/")

  class MyClass @Inject() (openAIService: OpenAIService) {...}

  service.listModels.map(models =>
    models.foreach(println)
  )

  service.retrieveModel(ModelId.text_davinci_003).map(model =>
    println(model.getOrElse("N/A"))
  )

  val text = """Extract the name and mailing address from this email:
               |Dear Kelly,
               |It was great to talk to you at the seminar. I thought Jane's talk was quite good.
               |Thank you for the book. Here's my address 2111 Ash Lane, Crestview CA 92002
               |Best,
               |Maya
             """.stripMargin

  service.createCompletion(text).map(completion =>
    println(completion.choices.head.text)
  )

  val text = """Extract the name and mailing address from this email:
               |Dear Kelly,
               |It was great to talk to you at the seminar. I thought Jane's talk was quite good.
               |Thank you for the book. Here's my address 2111 Ash Lane, Crestview CA 92002
               |Best,
               |Maya
             """.stripMargin

  service.createCompletion(
    text,
    settings = CreateCompletionSettings(
      model = ModelId.text_davinci_001,
      max_tokens = Some(1500),
      temperature = Some(0.9),
      presence_penalty = Some(0.2),
      frequency_penalty = Some(0.2)
    )
  ).map(completion =>
    println(completion.choices.head.text)
  )

import io.cequence.openaiscala.service.OpenAICountTokensHelper
import io.cequence.openaiscala.domain.{ChatRole, FunMessageSpec, FunctionSpec}

class MyCompletionService extends OpenAICountTokensHelper {
  def exec = {
    val messages: Seq[FunMessageSpec] = ??? // messages to be sent to OpenAI
    val function: FunctionSpec = ??? // function to be called

    val tokens = countFunMessageTokens(messages, List(function), Some(function.name))
  }
}

  val source = service.createCompletionStreamed(
    prompt = "Write me a Shakespeare poem about two cats playing baseball in Russia using at least 2 pages",
    settings = CreateCompletionSettings(
      model = ModelId.text_davinci_003,
      max_tokens = Some(1500),
      temperature = Some(0.9),
      presence_penalty = Some(0.2),
      frequency_penalty = Some(0.2)
    )
  )

  source.map(completion => 
    println(completion.choices.head.text)
  ).runWith(Sink.ignore)

  val createChatCompletionSettings = CreateChatCompletionSettings(
    model = ModelId.gpt_3_5_turbo
  )

  val messages = Seq(
    SystemMessage("You are a helpful assistant."),
    UserMessage("Who won the world series in 2020?"),
    AssistantMessage("The Los Angeles Dodgers won the World Series in 2020."),
    UserMessage("Where was it played?"),
  )

  service.createChatCompletion(
    messages = messages,
    settings = createChatCompletionSettings
  ).map { chatCompletion =>
    println(chatCompletion.choices.head.message.content)
  }

  val messages = Seq(
    FunMessageSpec(role = ChatRole.User, content = Some("What's the weather like in Boston?")),
  )

  // as a param type we can use "number", "string", "boolean", "object", "array", and "null"
  val functions = Seq(
    FunctionSpec(
      name = "get_current_weather",
      description = Some("Get the current weather in a given location"),
      parameters = Map(
        "type" -> "object",
        "properties" -> Map(
          "location" -> Map(
            "type" -> "string",
            "description" -> "The city and state, e.g. San Francisco, CA",
          ),
          "unit" -> Map(
            "type" -> "string",
            "enum" -> Seq("celsius", "fahrenheit")
          )
        ),
        "required" -> Seq("location"),
      )
    )
  )

  // if we want to force the model to use the above function as a response
  // we can do so by passing: responseFunctionName = Some("get_current_weather")`
  service.createChatFunCompletion(
    messages = messages,
    functions = functions,
    responseFunctionName = None
  ).map { response =>
    val chatFunCompletionMessage = response.choices.head.message
    val functionCall = chatFunCompletionMessage.function_call

    println("function call name      : " + functionCall.map(_.name).getOrElse("N/A"))
    println("function call arguments : " + functionCall.map(_.arguments).getOrElse("N/A"))
  }

  val service1 = OpenAIServiceFactory("your-api-key1")
  val service2 = OpenAIServiceFactory("your-api-key2")
  val service3 = OpenAIServiceFactory("your-api-key3")

  val service = OpenAIMultiServiceAdapter.ofRoundRobinType(service1, service2, service3)

  service.listModels.map { models =>
    models.foreach(println)
    service.close()
  }

  val service1 = OpenAIServiceFactory("your-api-key1")
  val service2 = OpenAIServiceFactory("your-api-key2")
  val service3 = OpenAIServiceFactory("your-api-key3")

  val service = OpenAIMultiServiceAdapter.ofRandomOrderType(service1, service2, service3)

  service.listModels.map { models =>
    models.foreach(println)
    service.close()
  }

import akka.actor.{ActorSystem, Scheduler}
import io.cequence.openaiscala.RetryHelpers
import io.cequence.openaiscala.RetryHelpers.RetrySettings
import io.cequence.openaiscala.domain.{ChatRole, MessageSpec}
import io.cequence.openaiscala.service.{OpenAIService, OpenAIServiceFactory}

import javax.inject.Inject
import scala.concurrent.duration.DurationInt
import scala.concurrent.{ExecutionContext, Future}

class MyCompletionService @Inject() (
  val actorSystem: ActorSystem,
  implicit val ec: ExecutionContext,
  implicit val scheduler: Scheduler
)(val apiKey: String)
  extends RetryHelpers {
  val service: OpenAIService = OpenAIServiceFactory(apiKey)
  implicit val retrySettings: RetrySettings =
    RetrySettings(interval = 10.seconds)

  def ask(prompt: String): Future[String] =
    for {
      completion <- service
        .createChatCompletion(
          List(MessageSpec(ChatRole.User, prompt))
        )
        .retryOnFailure
    } yield completion.choices.head.message.content
}

  val serviceAux = ... // your service

  implicit val retrySettings: RetrySettings = 
    RetrySettings(maxRetries = 10).constantInterval(10.seconds)
  // wrap it with the retry adapter
  val service = OpenAIRetryServiceAdapter(serviceAux)

  service.listModels.map { models =>
    models.foreach(println)
    service.close
  }