My ChatGPT API Rust Client

A Rust library for interacting with OpenAI's ChatGPT API with streaming support. This library provides a simple and efficient way to communicate with OpenAI's API while handling streaming responses and token usage tracking.

Features

Stream or non-stream mode for API responses
Comprehensive error handling
Token usage tracking
Flexible output handling via callback functions
Type-safe API interactions
Async/await support

Installation

Add this to your Cargo.toml:

[dependencies]

my-chatgpt = { git = "https://github.com/yourusername/my-chatgpt.git" }

Usage

use my_chatgpt::chat::{send_chat, ChatError, UsageInfo};

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = "your-api-key";
    let model = "gpt-4";  // or any other supported model
    let instructions = "You are a helpful assistant.";
    let input = "Tell me about Rust programming language.";
    
    // Define a handler function for the API responses
    let handler = |usage: Option<&UsageInfo>, error: Option<&ChatError>, raw_chunk: Option<&serde_json::Value>| {
        if let Some(e) = error {
            eprintln!("Error: {:?}", e);
        }
        
        if let Some(u) = usage {
            println!("Input tokens: {}", u.input_tokens.unwrap_or(0));
            println!("Output tokens: {}", u.output_tokens.unwrap_or(0));
            println!("Total tokens: {}", u.total_tokens.unwrap_or(0));
        }
        
        // Process raw chunks if needed
        if let Some(chunk) = raw_chunk {
            // Do something with the raw chunk
        }
    };
    
    // Call the API with streaming enabled
    send_chat(instructions, input, api_key, model, true, handler).await?;
    
    Ok(())
}

Error Handling

The library provides a ChatError enum for different error cases:

pub enum ChatError {
    RequestError(String),    // Errors related to API requests
    ParseError(String),      // Errors in parsing responses
    NetworkError(String),    // Network-related errors
    Unknown(String),         // Other unexpected errors
}

Token Usage

Token usage information is provided via the UsageInfo struct:

pub struct UsageInfo {
    pub input_tokens: Option<u32>,    // Number of tokens in the input
    pub output_tokens: Option<u32>,   // Number of tokens in the output
    pub total_tokens: Option<u32>,    // Total tokens used
}

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT

my-chatgpt 0.1.2