Struct openai_flows::OpenAIFlows

pub struct OpenAIFlows { /* private fields */ }

The main struct for setting the basic configuration for OpenAI interface.

Implementations

impl OpenAIFlows

pub async fn chat_completion( &self, conversation_id: &str, sentence: &str, options: &ChatOptions<'_> ) -> Result<ChatResponse, String>

Create chat completion with the provided sentence. It uses OpenAI’s GPT-3.5 model to make a conversation.

conversation_id is the identifier of the conversation. The history will be fetched and attached to the sentence as a whole prompt for ChatGPT.

sentence is a String that reprensents the current utterance of the conversation.

If you haven’t connected your OpenAI account with Flows.network platform, you will receive an error in the flow’s building log or running log.

     // Create a conversation_id.
     // Only numbers, letters, underscores, dashes, and pound signs are allowed, up to 50 characters.
     let chat_id = format!("news-summary-N");
     // System_prompt content in text.
     let system = &format!("You're a news editor AI.");

     // Create ChatOptions.
     let co = ChatOptions {
         model: ChatModel::GPT35Turbo16K,
         restart: true,
         system_prompt: Some(system),
     // Use .. to extract the default value for the remaining fields.
         ..Default::default()
     };

     // Create a `sentence`, the concatenation of user prompt and the text to work with.
     let question = format!("Make a concise summary within 200 words on this: {news_body}.");

     // Chat completion to get the result and handle the failure.
     match openai.chat_completion(&chat_id, &question, &co).await {
         Ok(r) => Ok(r.choice),
         Err(e) =>  Err(e.into()),
     }

impl OpenAIFlows

pub async fn create_completion( &self, params: CompletionRequest ) -> Result<Vec<String>, String>

Create completion for the provided prompt and parameters.

params is a CompletionRequest object.

If you haven’t connected your OpenAI account with Flows.network platform, you will receive an error in the flow’s building log or running log.

// Preceeding code has obtained a question from the user in a String named `text`.
// Create a CompletionRequest.
let cr = CompletionRequest {
    prompt: "I want you to act as my legal advisor. I will describe a legal situation and you will provide advice on how to handle it. My question is \"".to_owned() + text,
    max_tokens: 2048,
    ..Default::default()
};
// Call create_completion.
match openai.create_completion(cr).await {
   Ok(res) => res,
   Err(e) => {your error handling},
}

impl OpenAIFlows

pub async fn create_embeddings( &self, input: EmbeddingsInput ) -> Result<Vec<Vec<f64>>, String>

Create embeddings from the provided input.

params is an [EmbeddingsRequest] object.

If you haven’t connected your OpenAI account with Flows.network platform, you will receive an error in the flow’s building log or running log.

   // This code snippet computes embeddings for `text`, the question created in previous step.
   // Wrap the `text` in EmbeddingsInput struct.
   let input = EmbeddingsInput::String(text.to_string());
   // Call the create_embeddings function.
   let question_vector = match openai.create_embeddings(input).await {
       Ok(r) => r[0],
       Err(e) => {your error handling},
   };

impl OpenAIFlows

pub async fn create_image( &self, params: ImageRequest ) -> Result<Vec<String>, String>

Create image for the provided prompt and parameters.

params is a ImageRequest object.

If you haven’t connected your OpenAI account with Flows.network platform, you will receive an error in the flow’s building log or running log.

 // Create an instance of OpenAIFlows.
 let openai_flows = OpenAIFlows::new();
 // Create an `ImageRequest` instance.
 let image_request = ImageRequest {
     prompt: "An abstract representation of a summer sunrise".to_string(),
     n: 2,
     size: ImageSize::new(512, 512),
 };

 // Use `create_image` to generate images and handle the result.
 match openai_flows.create_image(image_request).await {
     Ok(images) => {
         for (i, image) in images.iter().enumerate() {
             println!("Image {}: {}", i + 1, image);
         }
         Ok(())
     }
     Err(e) => Err(format!("Failed to generate images: {}", e)),
 }

impl OpenAIFlows

pub fn new() -> OpenAIFlows

pub fn set_flows_account(&mut self, account: FlowsAccount)

pub fn set_retry_times(&mut self, retry_times: u8)