cURL examples

This section provides practical examples for using the YODI API with cURL to quickly test and integrate.

🔧 Basic setup

Environment variables

# Définir la clé API
export YODI_API_KEY="your-api-key-here"
export YODI_BASE_URL="https://api.yodi.tg/v1"

# Vérifier la configuration
echo "API Key: $YODI_API_KEY"
echo "Base URL: $YODI_BASE_URL"

Alias utiles

# Créer des alias pour simplifier les commandes
alias yodi-curl='curl -H "Authorization: Bearer $YODI_API_KEY" -H "Content-Type: application/json"'
alias yodi-post='yodi-curl -X POST'
alias yodi-get='yodi-curl -X GET'

# Test de connectivité
yodi-get "$YODI_BASE_URL/models"

🤖 Chat et génération de texte

Chat simple

# Requête de chat basique
curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-1",
"messages": [
{
"role": "system",
"content": "Tu es un assistant IA serviable et amical."
},
{
"role": "user",
"content": "Bonjour ! Comment ça va ?"
}
],
"temperature": 0.7,
"max_tokens": 200
}'

Chat avec personnalité

# Assistant expert en programmation
curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-1",
"messages": [
{
"role": "system",
"content": "Tu es un expert en programmation Python. Tu donnes des réponses précises avec des exemples de code."
},
{
"role": "user",
"content": "Comment créer une fonction qui calcule la factorielle ?"
}
],
"temperature": 0.3,
"max_tokens": 400
}' | jq '.choices[0].message.content'

Chat streaming

# Chat avec réponse en streaming
curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-1",
"messages": [
{
"role": "user",
"content": "Explique-moi le machine learning en détail."
}
],
"stream": true,
"temperature": 0.7,
"max_tokens": 800
}' --no-buffer

Conversation multi-tours

# Conversation avec historique
curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-1",
"messages": [
{
"role": "system",
"content": "Tu es un consultant en innovation technologique."
},
{
"role": "user",
"content": "Quelles sont les tendances IA en 2024 ?"
},
{
"role": "assistant",
"content": "Les principales tendances IA en 2024 incluent : 1) IA générative multimodale, 2) IA edge computing, 3) IA éthique et responsable, 4) Agents IA autonomes, 5) IA quantique. Souhaitez-vous des détails sur une tendance spécifique ?"
},
{
"role": "user",
"content": "Parle-moi des agents IA autonomes."
}
],
"temperature": 0.6,
"max_tokens": 500
}' | jq -r '.choices[0].message.content'

📝 Génération de contenu

Génération d'article de blog

# Article de blog optimisé SEO
curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-1",
"messages": [
{
"role": "user",
"content": "Écris un article de blog de 800 mots sur \"Intelligence artificielle dans le e-commerce\" avec les mots-clés : IA, e-commerce, personnalisation, conversion, automatisation. Inclus : titre accrocheur, introduction, 4 sections principales, conclusion avec CTA."
}
],
"temperature": 0.7,
"max_tokens": 1200
}' | jq -r '.choices[0].message.content' > article_ia_ecommerce.md

Génération de contenu marketing

# Description de produit persuasive
curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-1",
"messages": [
{
"role": "user",
"content": "Crée une description de produit persuasive pour : Casque audio sans fil ProSound avec réduction de bruit active, autonomie 30h, résistant à l\u0027eau IPX7, son haute définition. Public cible : professionnels urbains actifs. 150 mots maximum."
}
],
"temperature": 0.8,
"max_tokens": 250
}' | jq -r '.choices[0].message.content'

Génération de posts réseaux sociaux

# Post LinkedIn professionnel
curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-1",
"messages": [
{
"role": "user",
"content": "Crée un post LinkedIn professionnel sur \"Lancement de notre nouvelle plateforme IA\". Ton professionnel, 300 caractères max, 3 hashtags pertinents, optimisé engagement."
}
],
"temperature": 0.9,
"max_tokens": 150
}' | jq -r '.choices[0].message.content'

# Post Twitter viral
curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-1",
"messages": [
{
"role": "user",
"content": "Crée un tweet viral sur \"Les 5 erreurs à éviter avec l\u0027IA\". Maximum 280 caractères, ton accrocheur, 2 hashtags."
}
],
"temperature": 1.1,
"max_tokens": 100
}' | jq -r '.choices[0].message.content'

Génération d'emails

# Email de newsletter
curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-1",
"messages": [
{
"role": "user",
"content": "Génère un email de newsletter tech avec : objet accrocheur (max 50 chars), introduction engageante, 3 actualités IA récentes, CTA vers blog, signature. Ton professionnel mais accessible."
}
],
"temperature": 0.7,
"max_tokens": 600
}' | jq -r '.choices[0].message.content'

🔍 Analyse et traitement

Analyse de sentiment

# Analyser le sentiment d'un texte
TEXT="Ce produit est absolument fantastique ! Le service client est réactif et la livraison a été rapide. Je recommande vivement !"

curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"model\": \"yodi-instruct\",
\"messages\": [
{
\"role\": \"user\",
\"content\": \"Analyse le sentiment de ce texte et fournis : 1) Sentiment (positif/négatif/neutre), 2) Score de confiance (0-100%), 3) Émotions détectées, 4) Justification. Format JSON.\\n\\nTexte: \\\"$TEXT\\\"\"
}
],
\"temperature\": 0.2,
\"max_tokens\": 300
}" | jq '.choices[0].message.content | fromjson'

Extraction d'informations

# Extraire des informations de contact
EMAIL_TEXT="De: marie.martin@entreprise.com\\nSujet: Demande d'information\\n\\nBonjour,\\n\\nJe suis Marie Martin, Directrice Marketing chez TechCorp.\\nVous pouvez me joindre au 06.12.34.56.78.\\n\\nNotre adresse : 123 Rue de la Technologie, 75001 Paris"

curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"model\": \"yodi-instruct\",
\"messages\": [
{
\"role\": \"user\",
\"content\": \"Extrait les informations de contact de ce texte au format JSON avec les champs : nom, prenom, email, telephone, entreprise, poste, adresse. Si une info n'existe pas, utilise null.\\n\\nTexte:\\n$EMAIL_TEXT\"
}
],
\"temperature\": 0.1,
\"max_tokens\": 300
}" | jq '.choices[0].message.content | fromjson'

Résumé de document

# Résumer un long document
DOCUMENT="L'intelligence artificielle connaît une croissance exponentielle dans le secteur du e-commerce. Les entreprises utilisent l'IA pour personnaliser l'expérience client, optimiser les prix, gérer les stocks et améliorer le service client. Les chatbots IA permettent un support 24/7, tandis que les algorithmes de recommandation augmentent les ventes croisées de 35% en moyenne..."

curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"model\": \"yodi-1\",
\"messages\": [
{
\"role\": \"user\",
\"content\": \"Résume ce document en points clés numérotés (max 150 mots) :\\n\\n$DOCUMENT\"
}
],
\"temperature\": 0.3,
\"max_tokens\": 250
}" | jq -r '.choices[0].message.content'

Classification de texte

# Classifier des commentaires clients
COMMENT="L'interface est un peu confuse mais le produit fonctionne bien. Le prix est correct."

curl -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"model\": \"yodi-instruct\",
\"messages\": [
{
\"role\": \"user\",
\"content\": \"Classifie ce commentaire client selon ces catégories : PRODUIT, PRIX, INTERFACE, SERVICE_CLIENT, LIVRAISON. Retourne un JSON avec la catégorie principale et le score de confiance.\\n\\nCommentaire: \\\"$COMMENT\\\"\"
}
],
\"temperature\": 0.2,
\"max_tokens\": 150
}" | jq '.choices[0].message.content | fromjson'

🔍 Embeddings et recherche sémantique

Génération d'embeddings

# Créer un embedding pour un texte
curl -X POST "$YODI_BASE_URL/embeddings" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-embed",
"input": "L\u0027intelligence artificielle transforme le commerce électronique."
}' | jq '.data[0].embedding | length' # Affiche la dimension du vecteur

Embeddings par batch

# Créer des embeddings pour plusieurs textes
curl -X POST "$YODI_BASE_URL/embeddings" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-embed",
"input": [
"L\u0027IA révolutionne le e-commerce avec des recommandations personnalisées.",
"Les chatbots automatisent le service client efficacement.",
"L\u0027analyse prédictive optimise la gestion des stocks.",
"La sécurité des données est cruciale en IA."
]
}' | jq '.data | length' # Nombre d'embeddings générés

Comparaison de similarité

# Script pour comparer la similarité entre textes
cat << 'EOF' > similarity_check.sh
#!/bin/bash

TEXT1="$1"
TEXT2="$2"

# Obtenir les embeddings
EMBED1=$(curl -s -X POST "$YODI_BASE_URL/embeddings" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{\"model\": \"yodi-embed\", \"input\": \"$TEXT1\"}" | jq -r '.data[0].embedding')

EMBED2=$(curl -s -X POST "$YODI_BASE_URL/embeddings" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{\"model\": \"yodi-embed\", \"input\": \"$TEXT2\"}" | jq -r '.data[0].embedding')

# Calculer la similarité cosinus avec Python
python3 -c "
import json
import numpy as np

embed1 = json.loads('$EMBED1')
embed2 = json.loads('$EMBED2')

def cosine_similarity(a, b):
return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

similarity = cosine_similarity(embed1, embed2)
print(f'Similarité entre les textes: {similarity:.4f}')
"
EOF

chmod +x similarity_check.sh

# Utilisation
./similarity_check.sh "Intelligence artificielle" "Machine learning"

🚀 Scripts utilitaires

Script de test de performance

# test_performance.sh
#!/bin/bash

echo "=== Test de performance API YODI ==="

# Variables
REQUESTS=5
MODEL="yodi-1"
PROMPT="Explique brièvement l'intelligence artificielle."

echo "Nombre de requêtes: $REQUESTS"
echo "Modèle: $MODEL"
echo "Prompt: $PROMPT"
echo ""

TOTAL_TIME=0
SUCCESSFUL_REQUESTS=0

for i in $(seq 1 $REQUESTS); do
echo "Requête $i/$REQUESTS..."

START_TIME=$(date +%s.%N)

RESPONSE=$(curl -s -w "%{http_code}" -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"model\": \"$MODEL\",
\"messages\": [{\"role\": \"user\", \"content\": \"$PROMPT\"}],
\"max_tokens\": 100
}")

END_TIME=$(date +%s.%N)
REQUEST_TIME=$(echo "$END_TIME - $START_TIME" | bc)

HTTP_CODE="${RESPONSE: -3}"

if [ "$HTTP_CODE" = "200" ]; then
SUCCESSFUL_REQUESTS=$((SUCCESSFUL_REQUESTS + 1))
TOTAL_TIME=$(echo "$TOTAL_TIME + $REQUEST_TIME" | bc)
echo " ✓ Succès en ${REQUEST_TIME}s"
else
echo " ✗ Échec (HTTP $HTTP_CODE)"
fi

sleep 1
done

if [ $SUCCESSFUL_REQUESTS -gt 0 ]; then
AVERAGE_TIME=$(echo "scale=3; $TOTAL_TIME / $SUCCESSFUL_REQUESTS" | bc)
echo ""
echo "=== Résultats ==="
echo "Requêtes réussies: $SUCCESSFUL_REQUESTS/$REQUESTS"
echo "Temps moyen: ${AVERAGE_TIME}s"
echo "Temps total: ${TOTAL_TIME}s"
else
echo "Aucune requête réussie"
fi

Script de validation d'API

# validate_api.sh
#!/bin/bash

echo "=== Validation de l'API YODI ==="

# Fonction de test
test_endpoint() {
local name="$1"
local method="$2"
local endpoint="$3"
local data="$4"

echo -n "Test $name... "

if [ "$method" = "GET" ]; then
response=$(curl -s -w "%{http_code}" "$YODI_BASE_URL$endpoint" \
-H "Authorization: Bearer $YODI_API_KEY")
else
response=$(curl -s -w "%{http_code}" -X "$method" "$YODI_BASE_URL$endpoint" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "$data")
fi

http_code="${response: -3}"

if [ "$http_code" = "200" ]; then
echo "✓ PASS"
return 0
else
echo "✗ FAIL (HTTP $http_code)"
return 1
fi
}

# Tests
PASSED=0
TOTAL=0

# Test 1: Liste des modèles
TOTAL=$((TOTAL + 1))
if test_endpoint "Liste des modèles" "GET" "/models" ""; then
PASSED=$((PASSED + 1))
fi

# Test 2: Chat completion
TOTAL=$((TOTAL + 1))
CHAT_DATA='{
"model": "yodi-1",
"messages": [{"role": "user", "content": "Hello"}],
"max_tokens": 10
}'
if test_endpoint "Chat completion" "POST" "/chat/completions" "$CHAT_DATA"; then
PASSED=$((PASSED + 1))
fi

# Test 3: Embeddings
TOTAL=$((TOTAL + 1))
EMBED_DATA='{
"model": "yodi-embed",
"input": "Test text"
}'
if test_endpoint "Embeddings" "POST" "/embeddings" "$EMBED_DATA"; then
PASSED=$((PASSED + 1))
fi

echo ""
echo "=== Résultats ==="
echo "Tests réussis: $PASSED/$TOTAL"
if [ $PASSED -eq $TOTAL ]; then
echo "🎉 Tous les tests sont passés !"
exit 0
else
echo " Certains tests ont échoué"
exit 1
fi

Script de monitoring

# monitor_api.sh
#!/bin/bash

echo "=== Monitoring API YODI ==="

# Configuration
INTERVAL=30 # secondes
LOG_FILE="yodi_monitor.log"

monitor_health() {
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')

# Test simple de santé
local start_time=$(date +%s.%N)
local response=$(curl -s -w "%{http_code}" \
-X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-1",
"messages": [{"role": "user", "content": "test"}],
"max_tokens": 1
}')
local end_time=$(date +%s.%N)

local response_time=$(echo "$end_time - $start_time" | bc)
local http_code="${response: -3}"

local status="HEALTHY"
if [ "$http_code" != "200" ]; then
status="UNHEALTHY"
fi

local log_entry="$timestamp | Status: $status | HTTP: $http_code | Response Time: ${response_time}s"
echo "$log_entry"
echo "$log_entry" >> "$LOG_FILE"
}

echo "Démarrage du monitoring (intervalle: ${INTERVAL}s)"
echo "Logs sauvegardés dans: $LOG_FILE"
echo "Appuyez sur Ctrl+C pour arrêter"
echo ""

while true; do
monitor_health
sleep $INTERVAL
done

Script de backup des conversations

# backup_conversations.sh
#!/bin/bash

BACKUP_DIR="./conversations_backup"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="$BACKUP_DIR/conversation_$DATE.json"

mkdir -p "$BACKUP_DIR"

echo "Sauvegarde d'une conversation interactive..."

# Conversation interactive avec sauvegarde
conversation_backup() {
local messages='[]'

echo "Tapez 'quit' pour terminer et sauvegarder."
echo ""

while true; do
read -p "Vous: " user_input

if [ "$user_input" = "quit" ]; then
break
fi

# Ajouter le message utilisateur
messages=$(echo "$messages" | jq ". += [{\"role\": \"user\", \"content\": \"$user_input\", \"timestamp\": \"$(date -Iseconds)\"}]")

# Obtenir la réponse
response=$(curl -s -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"model\": \"yodi-1\",
\"messages\": $(echo "$messages" | jq '[.[] | {role, content}]'),
\"temperature\": 0.7,
\"max_tokens\": 300
}")

assistant_content=$(echo "$response" | jq -r '.choices[0].message.content')
echo "Assistant: $assistant_content"
echo ""

# Ajouter la réponse de l'assistant
messages=$(echo "$messages" | jq ". += [{\"role\": \"assistant\", \"content\": \"$assistant_content\", \"timestamp\": \"$(date -Iseconds)\"}]")
done

# Sauvegarder la conversation
echo "{
\"conversation_id\": \"conv_$DATE\",
\"created_at\": \"$(date -Iseconds)\",
\"model\": \"yodi-1\",
\"messages\": $messages
}" > "$BACKUP_FILE"

echo "Conversation sauvegardée dans: $BACKUP_FILE"
}

conversation_backup

📊 Analyse et reporting

Génération de rapport d'usage

# usage_report.sh
#!/bin/bash

echo "=== Rapport d'usage API YODI ==="

# Test de différents modèles
MODELS=("yodi-1" "yodi-instruct" "yodi-embed")
TEST_PROMPT="Test de performance"

for model in "${MODELS[@]}"; do
echo ""
echo "Test du modèle: $model"
echo "------------------------"

start_time=$(date +%s.%N)

if [ "$model" = "yodi-embed" ]; then
response=$(curl -s -X POST "$YODI_BASE_URL/embeddings" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{\"model\": \"$model\", \"input\": \"$TEST_PROMPT\"}")

success=$(echo "$response" | jq -r '.data[0].embedding | length > 0')
else
response=$(curl -s -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"model\": \"$model\",
\"messages\": [{\"role\": \"user\", \"content\": \"$TEST_PROMPT\"}],
\"max_tokens\": 50
}")

success=$(echo "$response" | jq -r '.choices[0].message.content | length > 0')
fi

end_time=$(date +%s.%N)
response_time=$(echo "$end_time - $start_time" | bc)

if [ "$success" = "true" ]; then
echo "Status: ✓ Disponible"
echo "Temps de réponse: ${response_time}s"
else
echo "Status: ✗ Indisponible"
fi
done

echo ""
echo "=== Résumé ==="
echo "Date du test: $(date)"
echo "Endpoint testé: $YODI_BASE_URL"

🔧 Scripts de développement

Générateur de données de test

# generate_test_data.sh
#!/bin/bash

echo "Génération de données de test avec YODI..."

# Générer des questions FAQ
generate_faq() {
local topic="$1"
local count="$2"

echo "Génération de $count questions FAQ sur: $topic"

for i in $(seq 1 $count); do
response=$(curl -s -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"model\": \"yodi-1\",
\"messages\": [{
\"role\": \"user\",
\"content\": \"Génère une question FAQ réaliste sur le sujet: $topic. Juste la question, pas la réponse.\"
}],
\"temperature\": 0.9,
\"max_tokens\": 50
}")

question=$(echo "$response" | jq -r '.choices[0].message.content')
echo "Q$i: $question"

sleep 0.5
done
}

# Générer des avis clients
generate_reviews() {
local product="$1"
local count="$2"

echo "Génération de $count avis clients pour: $product"

sentiments=("très positif" "positif" "neutre" "négatif" "mitigé")

for i in $(seq 1 $count); do
sentiment=${sentiments[$((RANDOM % ${#sentiments[@]}))]}

response=$(curl -s -X POST "$YODI_BASE_URL/chat/completions" \
-H "Authorization: Bearer $YODI_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"model\": \"yodi-1\",
\"messages\": [{
\"role\": \"user\",
\"content\": \"Génère un avis client $sentiment (50-100 mots) pour le produit: $product\"
}],
\"temperature\": 0.8,
\"max_tokens\": 150
}")

review=$(echo "$response" | jq -r '.choices[0].message.content')
echo "Avis $i ($sentiment): $review"
echo ""

sleep 0.5
done
}

# Usage
generate_faq "Intelligence Artificielle" 5
echo ""
generate_reviews "Casque audio sans fil" 3

Ces exemples cURL vous permettent de tester rapidement l'API YODI et d'intégrer ses fonctionnalités dans vos workflows de développement.

🔧 Basic setup​

Environment variables​

Alias utiles​

🤖 Chat et génération de texte​

Chat simple​

Chat avec personnalité​

Chat streaming​

Conversation multi-tours​

📝 Génération de contenu​

Génération d'article de blog​

Génération de contenu marketing​

Génération de posts réseaux sociaux​

Génération d'emails​

🔍 Analyse et traitement​

Analyse de sentiment​

Extraction d'informations​

Résumé de document​

Classification de texte​

🔍 Embeddings et recherche sémantique​

Génération d'embeddings​

Embeddings par batch​

Comparaison de similarité​

🚀 Scripts utilitaires​

Script de test de performance​

Script de validation d'API​

Script de monitoring​

Script de backup des conversations​

📊 Analyse et reporting​

Génération de rapport d'usage​

🔧 Scripts de développement​

Générateur de données de test​

Prochaines étapes​