SemanticPen Rust SDK

Official Rust SDK for the SemanticPen API - AI-powered content generation made simple.

Installation

Add this to your Cargo.toml:

[dependencies]
semanticpen = "0.1.0"

Quick Start

use semanticpen::{SemanticPenClient, ClientConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create client
    let client = SemanticPenClient::new("your-api-key-here".to_string())?;
    
    // Generate article
    let response = client.generate_article("rust programming tutorial", None).await?;
    
    // Get article ID
    if let Some(article_id) = response.get_article_id() {
        println!("Article ID: {}", article_id);
        
        // Wait for completion
        let article = client.wait_for_article(&article_id, None).await?;
        println!("Status: {}", article.status);
        
        if let Some(html) = article.article_html {
            println!("Content length: {}", html.len());
        }
    }
    
    Ok(())
}

Features

• Async/Await Support: Built on tokio for modern async Rust
• Type Safety: Full type definitions with serde serialization
• Error Handling: Comprehensive error types with thiserror
• Configurable: Timeout, debug mode, and base URL configuration
• Polling Support: Built-in waiting for article completion
• Bulk Generation: Generate multiple articles efficiently

Configuration

use semanticpen::{SemanticPenClient, ClientConfig};

let config = ClientConfig {
    base_url: "https://www.semanticpen.com".to_string(),
    timeout_seconds: 60,
    debug: true,
};

let client = SemanticPenClient::with_config("your-api-key".to_string(), config)?;

API Reference

Client Methods

generate_article(target_keyword, project_name)

Generate a single article.

let response = client.generate_article("rust tutorial", Some("My Project")).await?;

get_article(article_id)

Get article status and content.

let article = client.get_article("article-123").await?;

wait_for_article(article_id, polling_config)

Wait for article completion with polling.

use semanticpen::PollingConfig;

let config = PollingConfig {
    interval_seconds: 5,
    max_attempts: 60,
};

let article = client.wait_for_article("article-123", Some(config)).await?;

generate_article_and_wait(target_keyword, project_name, polling_config)

Generate and wait for completion in one call.

let article = client.generate_article_and_wait(
    "rust tutorial", 
    Some("My Project"),
    None
).await?;

generate_bulk_articles(keywords, project_name)

Generate multiple articles.

let keywords = vec!["rust tutorial".to_string(), "async rust".to_string()];
let article_ids = client.generate_bulk_articles(&keywords, None).await?;

Types

Article

pub struct Article {
    pub id: String,
    pub target_keyword: String,
    pub status: String,
    pub progress: u8,
    pub article_html: Option<String>,
    pub error_message: Option<String>,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
}

GenerateArticleResponse

pub struct GenerateArticleResponse {
    pub article_id: Option<String>,
    pub article_ids: Option<Vec<String>>,
    pub project_id: String,
    pub message: String,
    pub processing_info: Option<String>,
    pub error: Option<String>,
}

Error Handling

The SDK uses SemanticPenError for all error cases:

use semanticpen::SemanticPenError;

match client.generate_article("test", None).await {
    Ok(response) => println!("Success!"),
    Err(SemanticPenError::Api { status, message }) => {
        println!("API Error {}: {}", status, message);
    }
    Err(SemanticPenError::RateLimit { message }) => {
        println!("Rate limited: {}", message);
    }
    Err(e) => println!("Other error: {}", e),
}

Examples

Check the examples/ directory for complete examples:

• simple.rs - Basic article generation
• bulk.rs - Bulk article generation

Run examples:

cargo run --example simple
cargo run --example bulk

Requirements

• Rust 1.60+
• Valid SemanticPen API key
• Internet connection

Links

• SemanticPen Website
• API Documentation
• Crates.io
• Repository

License

MIT License - see LICENSE file for details.