✍️ AI Writer - Génération de contenu avec templates

Introduction

Le module AI Writer de l'API OUPI vous donne accès à plus de 30 templates de génération de contenu optimisés. De la rédaction d'articles à la génération de code, en passant par les emails et les descriptions de produits, AI Writer automatise vos tâches de création de contenu.

🎯 Templates disponibles

Vue d'ensemble par catégorie

📝 Rédaction et articles

• article_generator : Générateur d'articles complets

• blog_section : Sections de blog

• summarize_text : Résumé de texte

• text_extender : Extension de texte

📧 Communication

• email_generator : Générateur d'emails

• cold_email : Emails de prospection

• welcome_email : Emails de bienvenue

🛍️ E-commerce

• product_description : Descriptions de produits

• product_name : Noms de produits

• product_benefits : Bénéfices produits

• amazon_product : Produits Amazon

📱 Réseaux sociaux

• social_media_post_tweet : Posts Twitter/X

• social_media_post_instagram : Posts Instagram

• social_media_post_linkedin : Posts LinkedIn

• social_media_post_facebook : Posts Facebook

✍️ Titres et accroches

• post_title_generator : Générateur de titres

• meta_description : Meta descriptions SEO

• headline_generator : Titres accrocheurs

💻 Développement

• ai_code_generator : Générateur de code

• explain_code : Explication de code

• code_comment : Commentaires de code

🎨 Créatif

• story_generator : Générateur d'histoires

• poem_generator : Générateur de poèmes

🌐 Traduction

• translate : Traduction multilingue

Et bien d'autres...

📋 Endpoints principaux

Vue d'ensemble

🚀 Générer du contenu

Endpoint principal

POST /api/aiwriter/generate

Paramètres communs

Body (FormData ou JSON) :

Paramètres requis :

• post_type (string) : Type de template (ex: "article_generator")

Paramètres optionnels (selon le template) :

• language (string) : Langue de génération (ex: "fr-FR", "en-US")

• tone_of_voice (string) : Ton de la réponse

  • "Professional"

  • "Friendly"

  • "Casual"

  • "Formal"

  • "Humorous"

• creativity (float) : Niveau de créativité (0.0 à 1.0)

  • 0.0 - 0.3 : Conservateur, prévisible

  • 0.4 - 0.7 : Équilibré (recommandé)

  • 0.8 - 1.0 : Très créatif, original

• maximum_length (int) : Longueur maximale en mots

📝 Exemple 1 : Générer un résumé de texte

Template : summarize_text

Cas d'usage :

• Résumer des articles longs

• Extraire les points clés de documents

• Créer des executive summaries

JavaScript/Node.js

const FormData = require('form-data');
const fetch = require('node-fetch');

const API_TOKEN = process.env.OUPI_API_TOKEN;
const BASE_URL = 'https://app.oupi.com/api';

async function summarizeText(textToSummarize) {
  const formData = new FormData();
  formData.append('post_type', 'summarize_text');
  formData.append('text_to_summary', textToSummarize);
  formData.append('maximum_length', '200');
  formData.append('creativity', '0.5');
  formData.append('tone_of_voice', 'Professional');
  formData.append('language', 'fr-FR');

  const response = await fetch(`${BASE_URL}/aiwriter/generate`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`
    },
    body: formData
  });

  if (!response.ok) {
    throw new Error(`Erreur HTTP: ${response.status}`);
  }

  const result = await response.json();
  console.log('✅ Résumé généré:');
  console.log(result.generated_content);
  
  return result;
}

// Utilisation
const longText = `
  Le réchauffement climatique est l'un des défis majeurs du 21ème siècle.
  Les températures moyennes mondiales ont augmenté de plus de 1°C depuis
  l'ère préindustrielle. Cette augmentation est principalement due aux
  émissions de gaz à effet de serre provenant des activités humaines...
  [texte long]
`;

summarizeText(longText)
  .then(result => {
    console.log('Document ID:', result.document_id);
    console.log('Tokens utilisés:', result.tokens_used);
  })
  .catch(error => console.error('❌ Erreur:', error));

Python

import requests
import os

API_TOKEN = os.getenv('OUPI_API_TOKEN')
BASE_URL = 'https://app.oupi.com/api'

def summarize_text(text_to_summarize):
    headers = {
        'Authorization': f'Bearer {API_TOKEN}'
    }
    
    data = {
        'post_type': 'summarize_text',
        'text_to_summary': text_to_summarize,
        'maximum_length': '200',
        'creativity': '0.5',
        'tone_of_voice': 'Professional',
        'language': 'fr-FR'
    }
    
    response = requests.post(
        f'{BASE_URL}/aiwriter/generate',
        headers=headers,
        data=data
    )
    
    response.raise_for_status()
    result = response.json()
    
    print('✅ Résumé généré:')
    print(result['generated_content'])
    
    return result

# Utilisation
long_text = """
Le réchauffement climatique est l'un des défis majeurs du 21ème siècle.
[...]
"""

try:
    result = summarize_text(long_text)
    print(f'Document ID: {result["document_id"]}')
    print(f'Tokens utilisés: {result["tokens_used"]}')
except Exception as e:
    print(f'❌ Erreur: {e}')

Réponse

Structure de la réponse :

{
  "status": "success",
  "generated_content": "Le réchauffement climatique représente un défi majeur avec une augmentation de 1°C des températures depuis l'ère préindustrielle, principalement causée par les émissions humaines de gaz à effet de serre.",
  "document_id": "doc_abc123",
  "tokens_used": 85,
  "model": "gpt-4",
  "created_at": "2024-12-18T10:35:00Z"
}

📧 Exemple 2 : Générer un email professionnel

Template : email_generator

Cas d'usage :

• Emails clients

• Réponses automatiques

• Follow-ups commerciaux

Paramètres spécifiques

async function generateEmail(recipient, subject, context) {
  const formData = new FormData();
  formData.append('post_type', 'email_generator');
  formData.append('email_recipient', recipient);
  formData.append('email_subject', subject);
  formData.append('email_context', context);
  formData.append('tone_of_voice', 'Professional');
  formData.append('language', 'fr-FR');
  formData.append('creativity', '0.6');

  const response = await fetch(`${BASE_URL}/aiwriter/generate`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${API_TOKEN}` },
    body: formData
  });

  const result = await response.json();
  return result.generated_content;
}

// Utilisation
generateEmail(
  'Client potentiel',
  'Proposition de collaboration',
  'Présenter nos services de développement web et proposer un rendez-vous'
)
.then(email => {
  console.log('📧 Email généré:\n');
  console.log(email);
});

🛍️ Exemple 3 : Description de produit e-commerce

Template : product_description

Cas d'usage :

• Fiches produits automatiques

• Descriptions multilingues

• Optimisation SEO

Exemple complet

async function generateProductDescription(productInfo) {
  const formData = new FormData();
  formData.append('post_type', 'product_description');
  formData.append('product_name', productInfo.name);
  formData.append('product_features', productInfo.features);
  formData.append('product_audience', productInfo.targetAudience);
  formData.append('tone_of_voice', 'Friendly');
  formData.append('language', 'fr-FR');
  formData.append('creativity', '0.7');
  formData.append('maximum_length', '150');

  const response = await fetch(`${BASE_URL}/aiwriter/generate`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${API_TOKEN}` },
    body: formData
  });

  const result = await response.json();
  return result;
}

// Utilisation
const productInfo = {
  name: 'Chaussures de running ProSpeed X',
  features: 'Semelle amortissante, tissu respirant, design ergonomique',
  targetAudience: 'Coureurs amateurs et professionnels'
};

generateProductDescription(productInfo)
  .then(result => {
    console.log('🛍️ Description générée:\n');
    console.log(result.generated_content);
  });

💻 Exemple 4 : Génération de code

Template : ai_code_generator

Cas d'usage :

• Génération rapide de fonctions

• Boilerplate code

• Prototypage

Exemple

def generate_code(description, language='python'):
    headers = {'Authorization': f'Bearer {API_TOKEN}'}
    
    data = {
        'post_type': 'ai_code_generator',
        'code_description': description,
        'code_language': language,
        'creativity': '0.5'
    }
    
    response = requests.post(
        f'{BASE_URL}/aiwriter/generate',
        headers=headers,
        data=data
    )
    
    result = response.json()
    return result['generated_content']

# Utilisation
code_description = "Fonction pour calculer la moyenne d'une liste de nombres"
generated_code = generate_code(code_description, 'python')

print('💻 Code généré:\n')
print(generated_code)

📱 Exemple 5 : Post réseaux sociaux

Template : social_media_post_tweet

Cas d'usage :

• Automatisation des posts

• Génération de contenu social

• Campagnes marketing

Batch generation pour plusieurs plateformes

async function generateSocialPosts(topic) {
  const platforms = [
    { type: 'social_media_post_tweet', name: 'Twitter' },
    { type: 'social_media_post_instagram', name: 'Instagram' },
    { type: 'social_media_post_linkedin', name: 'LinkedIn' }
  ];

  const posts = {};

  for (const platform of platforms) {
    const formData = new FormData();
    formData.append('post_type', platform.type);
    formData.append('post_topic', topic);
    formData.append('tone_of_voice', 'Friendly');
    formData.append('language', 'fr-FR');

    const response = await fetch(`${BASE_URL}/aiwriter/generate`, {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${API_TOKEN}` },
      body: formData
    });

    const result = await response.json();
    posts[platform.name] = result.generated_content;

    // Pause entre requêtes
    await new Promise(resolve => setTimeout(resolve, 1000));
  }

  return posts;
}

// Utilisation
generateSocialPosts('Lancement de notre nouvelle application mobile')
  .then(posts => {
    console.log('📱 Posts générés pour toutes les plateformes:\n');
    Object.entries(posts).forEach(([platform, content]) => {
      console.log(`\n${platform}:`);
      console.log(content);
      console.log('---');
    });
  });

📚 Lister les générateurs disponibles

Endpoint

GET /api/aiwriter/openai-list

Exemple

async function listGenerators() {
  const response = await fetch(`${BASE_URL}/aiwriter/openai-list`, {
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json'
    }
  });

  const data = await response.json();
  
  console.log(`📋 ${data.generators.length} générateurs disponibles:\n`);
  
  data.generators.forEach(generator => {
    console.log(`- ${generator.name}`);
    console.log(`  Slug: ${generator.slug}`);
    console.log(`  Description: ${generator.description}`);
    console.log('');
  });

  return data.generators;
}

// Utilisation
listGenerators();

ℹ️ Obtenir les détails d'un générateur

Endpoint

GET /api/aiwriter/generator/{slug}

Exemple

async function getGeneratorDetails(slug) {
  const response = await fetch(`${BASE_URL}/aiwriter/generator/${slug}`, {
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json'
    }
  });

  const data = await response.json();
  
  console.log('📝 Détails du générateur:\n');
  console.log('Nom:', data.name);
  console.log('Description:', data.description);
  console.log('Paramètres requis:', data.required_params);
  console.log('Paramètres optionnels:', data.optional_params);
  console.log('\nDocuments générés par l\'utilisateur:', data.user_documents.length);

  return data;
}

// Utilisation
getGeneratorDetails('article_generator');

⭐ Gérer les favoris

Ajouter aux favoris

Endpoint :

POST /api/aiwriter/favorite-openai-list-add

Exemple :

async function addToFavorites(generatorSlug) {
  const response = await fetch(`${BASE_URL}/aiwriter/favorite-openai-list-add`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      generator_slug: generatorSlug
    })
  });

  if (response.ok) {
    console.log('✅ Ajouté aux favoris');
  }
}

// Utilisation
addToFavorites('article_generator');

Retirer des favoris

Endpoint :

POST /api/aiwriter/favorite-openai-list-remove

Exemple :

async function removeFromFavorites(generatorSlug) {
  const response = await fetch(`${BASE_URL}/aiwriter/favorite-openai-list-remove`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      generator_slug: generatorSlug
    })
  });

  if (response.ok) {
    console.log('✅ Retiré des favoris');
  }
}

🎨 Cas d'usage avancés

1. Génération batch pour e-commerce

Scénario : Générer des descriptions pour 100 produits

class ProductDescriptionGenerator {
  constructor(apiToken) {
    this.apiToken = apiToken;
    this.baseUrl = 'https://app.oupi.com/api';
    this.queue = [];
    this.processing = false;
  }

  async generateBatch(products) {
    const results = [];
    
    for (const product of products) {
      try {
        const description = await this.generateOne(product);
        results.push({
          productId: product.id,
          description: description,
          status: 'success'
        });
        
        console.log(`✅ ${results.length}/${products.length} produits traités`);
        
        // Pause pour respecter le rate limit
        await new Promise(resolve => setTimeout(resolve, 2000));
      } catch (error) {
        results.push({
          productId: product.id,
          error: error.message,
          status: 'error'
        });
      }
    }
    
    return results;
  }

  async generateOne(product) {
    const formData = new FormData();
    formData.append('post_type', 'product_description');
    formData.append('product_name', product.name);
    formData.append('product_features', product.features.join(', '));
    formData.append('language', 'fr-FR');
    formData.append('tone_of_voice', 'Friendly');

    const response = await fetch(`${this.baseUrl}/aiwriter/generate`, {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${this.apiToken}` },
      body: formData
    });

    const result = await response.json();
    return result.generated_content;
  }
}

// Utilisation
const generator = new ProductDescriptionGenerator(process.env.OUPI_API_TOKEN);

const products = [
  { id: 1, name: 'Produit A', features: ['feature1', 'feature2'] },
  { id: 2, name: 'Produit B', features: ['feature3', 'feature4'] },
  // ... 100 produits
];

generator.generateBatch(products)
  .then(results => {
    const successful = results.filter(r => r.status === 'success').length;
    console.log(`\n✅ ${successful}/${results.length} descriptions générées avec succès`);
  });

2. Système de génération multilingue

Scénario : Générer le même contenu en plusieurs langues

async function generateMultilingual(content, languages = ['fr-FR', 'en-US', 'es-ES']) {
  const translations = {};

  for (const language of languages) {
    const formData = new FormData();
    formData.append('post_type', 'article_generator');
    formData.append('article_title', content.title);
    formData.append('article_keywords', content.keywords);
    formData.append('language', language);
    formData.append('tone_of_voice', 'Professional');

    const response = await fetch(`${BASE_URL}/aiwriter/generate`, {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${API_TOKEN}` },
      body: formData
    });

    const result = await response.json();
    translations[language] = result.generated_content;

    console.log(`✅ ${language} généré`);
    await new Promise(resolve => setTimeout(resolve, 2000));
  }

  return translations;
}

// Utilisation
const content = {
  title: 'Les avantages de l\'intelligence artificielle',
  keywords: 'IA, technologie, innovation'
};

generateMultilingual(content)
  .then(translations => {
    console.log('\n📚 Contenu généré en', Object.keys(translations).length, 'langues');
    Object.entries(translations).forEach(([lang, text]) => {
      console.log(`\n${lang}:`);
      console.log(text.substring(0, 200) + '...');
    });
  });

3. Pipeline de contenu automatisé

Scénario : Workflow complet de création de contenu

class ContentPipeline {
  constructor(apiToken) {
    this.apiToken = apiToken;
    this.baseUrl = 'https://app.oupi.com/api';
  }

  async createFullArticle(topic) {
    console.log('🚀 Début du pipeline de création...\n');

    // Étape 1 : Générer un titre
    console.log('1️⃣ Génération du titre...');
    const title = await this.generateTitle(topic);
    console.log(`✅ Titre: ${title}\n`);

    // Étape 2 : Générer le contenu principal
    console.log('2️⃣ Génération de l\'article...');
    const article = await this.generateArticle(title, topic);
    console.log(`✅ Article généré (${article.split(' ').length} mots)\n`);

    // Étape 3 : Générer la meta description
    console.log('3️⃣ Génération de la meta description...');
    const metaDescription = await this.generateMetaDescription(article);
    console.log(`✅ Meta: ${metaDescription}\n`);

    // Étape 4 : Générer le post social
    console.log('4️⃣ Génération du post Twitter...');
    const tweet = await this.generateSocialPost(title);
    console.log(`✅ Tweet: ${tweet}\n`);

    return {
      title,
      article,
      metaDescription,
      socialPosts: { twitter: tweet }
    };
  }

  async generateTitle(topic) {
    const formData = new FormData();
    formData.append('post_type', 'post_title_generator');
    formData.append('description', topic);
    formData.append('language', 'fr-FR');

    const response = await fetch(`${this.baseUrl}/aiwriter/generate`, {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${this.apiToken}` },
      body: formData
    });

    const result = await response.json();
    return result.generated_content.split('\n')[0]; // Premier titre
  }

  async generateArticle(title, topic) {
    const formData = new FormData();
    formData.append('post_type', 'article_generator');
    formData.append('article_title', title);
    formData.append('article_keywords', topic);
    formData.append('maximum_length', '800');
    formData.append('language', 'fr-FR');

    const response = await fetch(`${this.baseUrl}/aiwriter/generate`, {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${this.apiToken}` },
      body: formData
    });

    const result = await response.json();
    return result.generated_content;
  }

  async generateMetaDescription(content) {
    const formData = new FormData();
    formData.append('post_type', 'meta_description');
    formData.append('content', content.substring(0, 500));
    formData.append('language', 'fr-FR');

    const response = await fetch(`${this.baseUrl}/aiwriter/generate`, {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${this.apiToken}` },
      body: formData
    });

    const result = await response.json();
    return result.generated_content;
  }

  async generateSocialPost(title) {
    const formData = new FormData();
    formData.append('post_type', 'social_media_post_tweet');
    formData.append('post_topic', title);
    formData.append('language', 'fr-FR');

    const response = await fetch(`${this.baseUrl}/aiwriter/generate`, {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${this.apiToken}` },
      body: formData
    });

    const result = await response.json();
    return result.generated_content;
  }
}

// Utilisation
const pipeline = new ContentPipeline(process.env.OUPI_API_TOKEN);

pipeline.createFullArticle('Intelligence artificielle et santé')
  .then(content => {
    console.log('🎉 Pipeline terminé!\n');
    console.log('📦 Contenu créé:');
    console.log('- Article complet');
    console.log('- Meta description SEO');
    console.log('- Post Twitter');
  });

💡 Bonnes pratiques

1. Optimisation des paramètres

Ajustez la créativité selon le contexte :

const creativityLevels = {
  technical: 0.3,      // Documentation, code
  professional: 0.5,   // Emails, articles pro
  marketing: 0.7,      // Posts sociaux, slogans
  creative: 0.9        // Histoires, poésie
};

async function generateWithOptimalCreativity(type, content) {
  const creativity = creativityLevels[type] || 0.5;
  
  const formData = new FormData();
  formData.append('post_type', content.template);
  formData.append('creativity', creativity.toString());
  // ... autres paramètres
  
  return await generate(formData);
}

2. Cache des générations

Évitez de régénérer le même contenu :

const cache = new Map();

async function generateWithCache(params, cacheKey) {
  if (cache.has(cacheKey)) {
    console.log('📦 Utilisation du cache');
    return cache.get(cacheKey);
  }

  const result = await generateContent(params);
  cache.set(cacheKey, result);
  
  return result;
}

// Utilisation
const cacheKey = `summary_${hashString(longText)}`;
const summary = await generateWithCache(params, cacheKey);

3. Validation des résultats

Vérifiez la qualité des générations :

function validateGeneration(result, minLength = 50) {
  const checks = {
    hasContent: result.generated_content && result.generated_content.length > 0,
    meetsMinLength: result.generated_content.length >= minLength,
    noErrors: !result.error,
    hasTokens: result.tokens_used > 0
  };

  const isValid = Object.values(checks).every(check => check === true);
  
  if (!isValid) {
    console.warn('⚠️ Génération de qualité insuffisante:', checks);
  }

  return isValid;
}

// Utilisation
const result = await generateContent(params);
if (validateGeneration(result)) {
  console.log('✅ Génération valide');
} else {
  console.log('❌ Régénération nécessaire');
  result = await generateContent(params); // Retry
}

🐛 Gestion des erreurs spécifiques

Erreur : Template non trouvé

async function safeGenerate(templateSlug, params) {
  try {
    return await generate(templateSlug, params);
  } catch (error) {
    if (error.message.includes('template not found')) {
      // Lister les templates disponibles
      const generators = await listGenerators();
      const available = generators.map(g => g.slug).join(', ');
      throw new Error(`Template '${templateSlug}' invalide. Disponibles: ${available}`);
    }
    throw error;
  }
}

📊 Suivi de la consommation

class UsageTracker {
  constructor() {
    this.totalGenerations = 0;
    this.totalTokens = 0;
    this.byTemplate = {};
  }

  track(templateSlug, tokensUsed) {
    this.totalGenerations++;
    this.totalTokens += tokensUsed;
    
    if (!this.byTemplate[templateSlug]) {
      this.byTemplate[templateSlug] = { count: 0, tokens: 0 };
    }
    
    this.byTemplate[templateSlug].count++;
    this.byTemplate[templateSlug].tokens += tokensUsed;
  }

  getReport() {
    return {
      total: {
        generations: this.totalGenerations,
        tokens: this.totalTokens,
        estimatedCost: this.totalTokens * 0.002
      },
      byTemplate: this.byTemplate
    };
  }
}

// Utilisation
const tracker = new UsageTracker();

async function generateWithTracking(template, params) {
  const result = await generateContent(template, params);
  tracker.track(template, result.tokens_used);
  return result;
}

✅ Checklist d'intégration

Avant la production :

• [ ] Templates nécessaires identifiés et testés

• [ ] Paramètres optimisés pour chaque use case

• [ ] Gestion d'erreurs robuste

• [ ] Cache implémenté si génération répétitive

• [ ] Validation des résultats en place

• [ ] Rate limiting respecté

• [ ] Suivi de la consommation actif

• [ ] Fallback en cas d'échec

• [ ] Tests avec données réelles

• [ ] Documentation interne

Automatisez votre création de contenu avec AI Writer ! ✍️

Dernière mise à jour : Décembre 2024
Guide AI Writer - API OUPI v1.0