Cas d'usage complets
Cette section présente des exemples d'implémentation complète pour des cas d'usage réels avec l'API YODI.
🛒 E-commerce intelligent
Système de recommandation personnalisé
import json
import numpy as np
from datetime import datetime, timedelta
from typing import List, Dict, Any
import requests
from dotenv import load_dotenv
load_dotenv()
class EcommerceRecommendationEngine:
def __init__(self, yodi_api_key: str):
self.yodi_api_key = yodi_api_key
self.base_url = "https://api.yodi.tg/v1"
self.headers = {
"Authorization": f"Bearer {yodi_api_key}",
"Content-Type": "application/json"
}
# Base de données simulée
self.products = []
self.user_interactions = {}
self.product_embeddings = {}
def add_products(self, products: List[Dict]):
"""Ajoute des produits à la base et génère leurs embeddings"""
self.products.extend(products)
# Générer les embeddings pour chaque produit
for product in products:
product_description = f"{product['name']} {product['category']} {product['description']}"
embedding = self._generate_embedding(product_description)
self.product_embeddings[product['id']] = embedding
def track_interaction(self, user_id: str, product_id: str, interaction_type: str, weight: float = 1.0):
"""Enregistre une interaction utilisateur"""
if user_id not in self.user_interactions:
self.user_interactions[user_id] = []
self.user_interactions[user_id].append({
'product_id': product_id,
'type': interaction_type, # view, click, purchase, like
'weight': weight,
'timestamp': datetime.now().isoformat()
})
def generate_recommendations(self, user_id: str, count: int = 5) -> List[Dict]:
"""Génère des recommandations personnalisées"""
if user_id not in self.user_interactions:
return self._get_popular_products(count)
# Calculer le profil utilisateur basé sur les interactions
user_profile = self._build_user_profile(user_id)
# Calculer les scores de recommandation
recommendations = []
for product in self.products:
if self._user_already_purchased(user_id, product['id']):
continue
# Score basé sur la similarité
similarity_score = self._calculate_similarity(
user_profile,
self.product_embeddings[product['id']]
)
# Score basé sur les tendances
trend_score = self._calculate_trend_score(product)
# Score composite
final_score = 0.7 * similarity_score + 0.3 * trend_score
recommendations.append({
'product': product,
'score': final_score,
'reasons': self._generate_recommendation_reasons(user_id, product)
})
# Trier par score et retourner le top N
recommendations.sort(key=lambda x: x['score'], reverse=True)
return recommendations[:count]
def _generate_embedding(self, text: str) -> np.ndarray:
"""Génère un embedding pour un texte"""
response = requests.post(
f"{self.base_url}/embeddings",
headers=self.headers,
json={
"model": "yodi-embed",
"input": text
}
)
if response.status_code == 200:
return np.array(response.json()['data'][0]['embedding'])
else:
raise Exception(f"Erreur API: {response.status_code}")
def _build_user_profile(self, user_id: str) -> np.ndarray:
"""Construit le profil utilisateur basé sur ses interactions"""
interactions = self.user_interactions[user_id]
# Pondérer les interactions récentes plus fortement
weighted_embeddings = []
total_weight = 0
for interaction in interactions:
product_id = interaction['product_id']
if product_id in self.product_embeddings:
# Calcul du poids temporel (interactions récentes = plus de poids)
days_ago = (datetime.now() - datetime.fromisoformat(interaction['timestamp'])).days
time_weight = max(0.1, 1.0 - (days_ago / 30)) # Décroissance sur 30 jours
# Poids par type d'interaction
type_weights = {'view': 1.0, 'click': 2.0, 'like': 3.0, 'purchase': 5.0}
interaction_weight = type_weights.get(interaction['type'], 1.0)
final_weight = time_weight * interaction_weight * interaction['weight']
weighted_embeddings.append(
self.product_embeddings[product_id] * final_weight
)
total_weight += final_weight
if not weighted_embeddings:
return np.zeros(1536) # Dimension embedding YODI
# Moyenne pondérée
user_profile = np.sum(weighted_embeddings, axis=0) / total_weight
return user_profile
def _calculate_similarity(self, profile: np.ndarray, product_embedding: np.ndarray) -> float:
"""Calcule la similarité cosinus"""
if np.linalg.norm(profile) == 0 or np.linalg.norm(product_embedding) == 0:
return 0.0
return np.dot(profile, product_embedding) / (
np.linalg.norm(profile) * np.linalg.norm(product_embedding)
)
def _calculate_trend_score(self, product: Dict) -> float:
"""Calcule le score de tendance d'un produit"""
# Simuler des métriques de tendance
base_score = 0.5
# Boost pour les nouveautés
if product.get('is_new', False):
base_score += 0.2
# Boost pour les promotions
if product.get('on_sale', False):
base_score += 0.15
# Score basé sur les ventes récentes (simulé)
recent_sales = product.get('recent_sales', 0)
sales_score = min(0.3, recent_sales / 100)
return min(1.0, base_score + sales_score)
def _user_already_purchased(self, user_id: str, product_id: str) -> bool:
"""Vérifie si l'utilisateur a déjà acheté ce produit"""
if user_id not in self.user_interactions:
return False
return any(
interaction['product_id'] == product_id and interaction['type'] == 'purchase'
for interaction in self.user_interactions[user_id]
)
def _generate_recommendation_reasons(self, user_id: str, product: Dict) -> List[str]:
"""Génère les raisons de recommandation avec l'IA"""
user_history = self.user_interactions.get(user_id, [])
# Analyser les préférences utilisateur
prompt = f"""Analyse les interactions d'un utilisateur e-commerce et explique pourquoi recommander ce produit :
Historique utilisateur (dernières interactions) :
{json.dumps(user_history[-10:], indent=2)}
Produit recommandé :
- Nom : {product['name']}
- Catégorie : {product['category']}
- Description : {product['description']}
- Prix : {product['price']}€
Génère 2-3 raisons personnalisées expliquant pourquoi ce produit correspond aux goûts de l'utilisateur.
Format : liste de raisons courtes et engageantes.
Raisons :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-1",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.7,
"max_tokens": 200
}
)
if response.status_code == 200:
reasons_text = response.json()['choices'][0]['message']['content']
return [reason.strip() for reason in reasons_text.split('\n') if reason.strip()]
else:
return ["Recommandé pour vous"]
def _get_popular_products(self, count: int) -> List[Dict]:
"""Retourne les produits populaires pour les nouveaux utilisateurs"""
popular = sorted(
self.products,
key=lambda p: p.get('recent_sales', 0),
reverse=True
)[:count]
return [{'product': p, 'score': 0.8, 'reasons': ['Produit populaire']} for p in popular]
# Utilisation du système de recommandation
def demo_ecommerce_recommendations():
# Initialisation
recommender = EcommerceRecommendationEngine("your-yodi-api-key")
# Ajouter des produits
products = [
{
'id': 'prod_001',
'name': 'iPhone 15 Pro',
'category': 'Smartphones',
'description': 'Smartphone premium avec appareil photo professionnel',
'price': 1199,
'is_new': True,
'recent_sales': 85
},
{
'id': 'prod_002',
'name': 'MacBook Air M2',
'category': 'Ordinateurs',
'description': 'Ordinateur portable ultra-léger pour professionnels',
'price': 1299,
'recent_sales': 92
},
{
'id': 'prod_003',
'name': 'AirPods Pro',
'category': 'Audio',
'description': 'Écouteurs sans fil avec réduction de bruit',
'price': 279,
'on_sale': True,
'recent_sales': 150
},
{
'id': 'prod_004',
'name': 'iPad Pro 12.9"',
'category': 'Tablettes',
'description': 'Tablette professionnelle pour créateurs',
'price': 1099,
'recent_sales': 67
}
]
recommender.add_products(products)
# Simuler des interactions utilisateur
user_id = "user_123"
recommender.track_interaction(user_id, 'prod_001', 'view')
recommender.track_interaction(user_id, 'prod_001', 'click')
recommender.track_interaction(user_id, 'prod_003', 'view')
recommender.track_interaction(user_id, 'prod_003', 'purchase', weight=5.0)
recommender.track_interaction(user_id, 'prod_002', 'like', weight=3.0)
# Générer des recommandations
recommendations = recommender.generate_recommendations(user_id, count=3)
print("🛒 Recommandations personnalisées pour l'utilisateur :")
for i, rec in enumerate(recommendations, 1):
product = rec['product']
print(f"\n{i}. {product['name']} - {product['price']}€")
print(f" Score : {rec['score']:.3f}")
print(f" Raisons : {', '.join(rec['reasons'])}")
# demo_ecommerce_recommendations()
Assistant de service client automatisé
class CustomerServiceBot:
def __init__(self, yodi_api_key: str):
self.yodi_api_key = yodi_api_key
self.base_url = "https://api.yodi.tg/v1"
self.headers = {
"Authorization": f"Bearer {yodi_api_key}",
"Content-Type": "application/json"
}
# Base de connaissances
self.knowledge_base = {
'shipping': {
'standard': "Livraison standard : 3-5 jours ouvrés (gratuite dès 50€)",
'express': "Livraison express : 24-48h (9.99€)",
'tracking': "Vous pouvez suivre votre commande avec le numéro de suivi"
},
'returns': {
'policy': "Retours gratuits sous 30 jours",
'process': "Demandez un retour depuis votre compte client",
'refund': "Remboursement sous 5-7 jours après réception"
},
'warranty': {
'duration': "Garantie 2 ans sur tous nos produits",
'coverage': "Défauts de fabrication couverts",
'contact': "Support technique : tech@example.com"
}
}
self.conversation_history = {}
def process_customer_request(self, customer_id: str, message: str, order_id: str = None) -> Dict:
"""Traite une demande client"""
# Analyser l'intention du message
intent = self._analyze_intent(message)
# Extraire les informations importantes
extracted_info = self._extract_information(message)
# Générer une réponse appropriée
response = self._generate_response(customer_id, message, intent, extracted_info, order_id)
# Sauvegarder l'historique
self._save_conversation(customer_id, message, response)
return {
'response': response,
'intent': intent,
'extracted_info': extracted_info,
'needs_human': self._needs_human_intervention(intent, message),
'suggested_actions': self._suggest_actions(intent, extracted_info)
}
def _analyze_intent(self, message: str) -> Dict:
"""Analyse l'intention du message client"""
prompt = f"""Analyse ce message client et détermine l'intention principale :
Message : "{message}"
Catégorise selon ces intentions possibles :
- question_produit : Questions sur un produit spécifique
- commande_statut : Demande de statut de commande
- livraison : Questions sur la livraison
- retour_remboursement : Demandes de retour ou remboursement
- probleme_technique : Problèmes techniques
- reclamation : Plaintes ou réclamations
- information_generale : Informations générales
- autre : Autres demandes
Retourne un JSON avec :
- intention : l'intention principale
- confiance : score de confiance (0-1)
- urgence : niveau d'urgence (faible/moyen/élevé)
- sentiment : sentiment client (positif/neutre/négatif)
JSON :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-instruct",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.2,
"max_tokens": 200
}
)
try:
return json.loads(response.json()['choices'][0]['message']['content'])
except:
return {
'intention': 'autre',
'confiance': 0.5,
'urgence': 'moyen',
'sentiment': 'neutre'
}
def _extract_information(self, message: str) -> Dict:
"""Extrait les informations importantes du message"""
prompt = f"""Extrait les informations utiles de ce message client :
Message : "{message}"
Extrait si présent :
- numero_commande : numéro de commande mentionné
- nom_produit : nom de produit mentionné
- probleme_specifique : description du problème
- email : adresse email
- telephone : numéro de téléphone
- date_mentionnee : date mentionnée
- montant : montant mentionné
Retourne un JSON. Si une information n'est pas présente, utilise null.
JSON :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-instruct",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.1,
"max_tokens": 250
}
)
try:
return json.loads(response.json()['choices'][0]['message']['content'])
except:
return {}
def _generate_response(self, customer_id: str, message: str, intent: Dict,
extracted_info: Dict, order_id: str = None) -> str:
"""Génère une réponse personnalisée"""
# Récupérer l'historique de conversation
history = self.conversation_history.get(customer_id, [])
# Construire le contexte
context = self._build_context(intent, extracted_info, order_id)
prompt = f"""Tu es un assistant de service client expert et empathique. Réponds à ce client de manière personnalisée et professionnelle.
Contexte de la demande :
- Intention : {intent.get('intention', 'autre')}
- Sentiment client : {intent.get('sentiment', 'neutre')}
- Urgence : {intent.get('urgence', 'moyen')}
Informations extraites :
{json.dumps(extracted_info, indent=2)}
Historique récent :
{json.dumps(history[-3:], indent=2) if history else "Première interaction"}
Contexte supplémentaire :
{context}
Message client : "{message}"
Règles pour la réponse :
1. Sois empathique et professionnel
2. Adresse directement le problème
3. Fournis des informations précises
4. Propose des solutions concrètes
5. Si tu ne peux pas résoudre, explique les prochaines étapes
6. Reste concis (150 mots max)
Réponse :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-1",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.7,
"max_tokens": 300
}
)
return response.json()['choices'][0]['message']['content']
def _build_context(self, intent: Dict, extracted_info: Dict, order_id: str = None) -> str:
"""Construit le contexte à partir de la base de connaissances"""
context_parts = []
intention = intent.get('intention', '')
if 'livraison' in intention:
context_parts.append("Informations livraison :")
context_parts.extend(self.knowledge_base['shipping'].values())
if 'retour' in intention:
context_parts.append("Politique de retours :")
context_parts.extend(self.knowledge_base['returns'].values())
if order_id:
# Simuler la récupération des données de commande
context_parts.append(f"Commande {order_id} : En cours de préparation")
return '\n'.join(context_parts)
def _needs_human_intervention(self, intent: Dict, message: str) -> bool:
"""Détermine si l'intervention humaine est nécessaire"""
# Critères pour escalader vers un humain
urgence_elevee = intent.get('urgence') == 'élevé'
sentiment_negatif = intent.get('sentiment') == 'négatif'
confiance_faible = intent.get('confiance', 1) < 0.6
mots_escalade = ['avocat', 'juridique', 'inacceptable', 'scandaleux', 'manager']
contient_escalade = any(mot in message.lower() for mot in mots_escalade)
return urgence_elevee or (sentiment_negatif and confiance_faible) or contient_escalade
def _suggest_actions(self, intent: Dict, extracted_info: Dict) -> List[str]:
"""Suggère des actions à entreprendre"""
actions = []
intention = intent.get('intention', '')
if intention == 'commande_statut' and extracted_info.get('numero_commande'):
actions.append(f"Vérifier le statut de la commande {extracted_info['numero_commande']}")
if intention == 'retour_remboursement':
actions.append("Initier le processus de retour")
actions.append("Envoyer l'étiquette de retour")
if 'probleme_technique' in intention:
actions.append("Créer un ticket support technique")
actions.append("Programmer un rappel technique")
if intent.get('urgence') == 'élevé':
actions.append("Escalader vers un superviseur")
return actions
def _save_conversation(self, customer_id: str, message: str, response: str):
"""Sauvegarde l'historique de conversation"""
if customer_id not in self.conversation_history:
self.conversation_history[customer_id] = []
self.conversation_history[customer_id].append({
'timestamp': datetime.now().isoformat(),
'customer_message': message,
'bot_response': response
})
# Garder seulement les 10 derniers échanges
self.conversation_history[customer_id] = self.conversation_history[customer_id][-10:]
# Utilisation du bot de service client
def demo_customer_service():
bot = CustomerServiceBot("your-yodi-api-key")
# Scénarios de test
scenarios = [
{
'customer_id': 'cust_001',
'message': "Bonjour, je n'ai pas reçu ma commande CMD-2024-001 commandée il y a 5 jours. Pouvez-vous me dire où elle en est ?",
'order_id': 'CMD-2024-001'
},
{
'customer_id': 'cust_002',
'message': "Je veux retourner mes écouteurs achetés la semaine dernière, ils ne fonctionnent pas correctement.",
'order_id': None
},
{
'customer_id': 'cust_003',
'message': "C'est inadmissible ! Ma commande arrive en retard et personne ne répond au téléphone. Je veux parler à votre manager !",
'order_id': None
}
]
for scenario in scenarios:
print(f"\n{'='*50}")
print(f"Client {scenario['customer_id']}")
print(f"Message : {scenario['message']}")
print(f"{'='*50}")
result = bot.process_customer_request(
scenario['customer_id'],
scenario['message'],
scenario['order_id']
)
print(f"\n🤖 Réponse du bot :")
print(result['response'])
print(f"\n📊 Analyse :")
print(f"- Intention : {result['intent']['intention']}")
print(f"- Sentiment : {result['intent']['sentiment']}")
print(f"- Urgence : {result['intent']['urgence']}")
print(f"- Intervention humaine nécessaire : {'Oui' if result['needs_human'] else 'Non'}")
if result['suggested_actions']:
print(f"\n🎯 Actions suggérées :")
for action in result['suggested_actions']:
print(f"- {action}")
# demo_customer_service()
📚 Plateforme éducative personnalisée
Tuteur IA adaptatif
class AdaptiveTutor:
def __init__(self, yodi_api_key: str):
self.yodi_api_key = yodi_api_key
self.base_url = "https://api.yodi.tg/v1"
self.headers = {
"Authorization": f"Bearer {yodi_api_key}",
"Content-Type": "application/json"
}
# Profils d'apprentissage
self.student_profiles = {}
# Base de connaissances par sujet
self.curriculum = {
'python_basics': [
'Variables et types de données',
'Structures de contrôle',
'Fonctions',
'Listes et dictionnaires',
'Classes et objets',
'Gestion des erreurs',
'Modules et packages'
],
'machine_learning': [
'Introduction au ML',
'Préparation des données',
'Algorithmes supervisés',
'Algorithmes non-supervisés',
'Évaluation des modèles',
'Deep Learning',
'Déploiement de modèles'
]
}
def create_student_profile(self, student_id: str, initial_assessment: Dict):
"""Crée un profil étudiant basé sur une évaluation initiale"""
self.student_profiles[student_id] = {
'id': student_id,
'created_at': datetime.now().isoformat(),
'learning_style': initial_assessment.get('learning_style', 'visual'),
'pace': initial_assessment.get('pace', 'medium'),
'subjects': initial_assessment.get('subjects', []),
'current_level': initial_assessment.get('level', 'beginner'),
'progress': {},
'strengths': [],
'weaknesses': [],
'learning_history': []
}
def assess_understanding(self, student_id: str, topic: str, response: str) -> Dict:
"""Évalue la compréhension d'un étudiant sur un sujet"""
prompt = f"""Évalue la compréhension d'un étudiant sur ce sujet :
Sujet : {topic}
Réponse de l'étudiant : "{response}"
Évalue selon ces critères :
1. Compréhension conceptuelle (0-100)
2. Précision technique (0-100)
3. Exemples et applications (0-100)
4. Lacunes identifiées
5. Points forts démontrés
Fournis aussi :
- Niveau de maîtrise : débutant/intermédiaire/avancé
- Suggestions d'amélioration
- Prochains sujets recommandés
Format JSON :"""
response_api = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-instruct",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.3,
"max_tokens": 400
}
)
try:
assessment = json.loads(response_api.json()['choices'][0]['message']['content'])
# Mettre à jour le profil étudiant
self._update_student_progress(student_id, topic, assessment)
return assessment
except:
return {'error': 'Erreur lors de l\'évaluation'}
def generate_personalized_lesson(self, student_id: str, topic: str) -> Dict:
"""Génère une leçon personnalisée"""
if student_id not in self.student_profiles:
return {'error': 'Profil étudiant non trouvé'}
profile = self.student_profiles[student_id]
prompt = f"""Crée une leçon personnalisée sur "{topic}" pour cet étudiant :
Profil de l'étudiant :
- Style d'apprentissage : {profile['learning_style']}
- Rythme préféré : {profile['pace']}
- Niveau actuel : {profile['current_level']}
- Forces : {', '.join(profile['strengths'])}
- Faiblesses : {', '.join(profile['weaknesses'])}
Structure de la leçon :
1. Introduction engageante (adaptée au style)
2. Objectifs d'apprentissage clairs
3. Concepts principaux avec exemples
4. Exercices pratiques progressifs
5. Récapitulatif et auto-évaluation
Adapte :
- Le vocabulaire au niveau
- Les exemples aux centres d'intérêt
- La complexité aux capacités actuelles
- Les activités au style d'apprentissage
Leçon :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-1",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.7,
"max_tokens": 1000
}
)
lesson_content = response.json()['choices'][0]['message']['content']
# Générer des exercices complémentaires
exercises = self._generate_exercises(student_id, topic)
return {
'topic': topic,
'content': lesson_content,
'exercises': exercises,
'estimated_duration': self._estimate_duration(profile['pace'], len(lesson_content)),
'prerequisites': self._get_prerequisites(topic),
'next_topics': self._suggest_next_topics(student_id, topic)
}
def provide_feedback(self, student_id: str, exercise_answer: str, correct_answer: str, topic: str) -> str:
"""Fournit un feedback personnalisé sur un exercice"""
profile = self.student_profiles.get(student_id, {})
prompt = f"""Fournis un feedback constructif et encourageant à cet étudiant :
Sujet : {topic}
Réponse de l'étudiant : "{exercise_answer}"
Réponse correcte : "{correct_answer}"
Style d'apprentissage de l'étudiant : {profile.get('learning_style', 'non spécifié')}
Le feedback doit :
1. Être encourageant et positif
2. Identifier ce qui est correct
3. Expliquer les erreurs sans décourager
4. Donner des conseils pour s'améliorer
5. Suggérer des ressources complémentaires si nécessaire
Ton : patient, pédagogique et motivant
Feedback :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-1",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.7,
"max_tokens": 300
}
)
return response.json()['choices'][0]['message']['content']
def generate_study_plan(self, student_id: str, subject: str, target_level: str,
weeks_available: int) -> Dict:
"""Génère un plan d'étude personnalisé"""
if student_id not in self.student_profiles:
return {'error': 'Profil étudiant non trouvé'}
profile = self.student_profiles[student_id]
current_level = profile['current_level']
prompt = f"""Crée un plan d'étude personnalisé :
Sujet : {subject}
Niveau actuel : {current_level}
Niveau cible : {target_level}
Durée disponible : {weeks_available} semaines
Rythme d'apprentissage : {profile['pace']}
Curriculum disponible : {self.curriculum.get(subject, [])}
Structure du plan :
- Semaine par semaine
- Objectifs hebdomadaires
- Ressources d'apprentissage
- Exercices pratiques
- Évaluations intermédiaires
- Temps estimé par activité
Prends en compte :
- Progression logique des concepts
- Révisions régulières
- Projets pratiques
- Adaptabilité selon les progrès
Plan d'étude :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-1",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.6,
"max_tokens": 800
}
)
return {
'subject': subject,
'duration_weeks': weeks_available,
'plan': response.json()['choices'][0]['message']['content'],
'milestones': self._extract_milestones(subject, weeks_available),
'adaptive_elements': self._get_adaptive_elements(student_id)
}
def _generate_exercises(self, student_id: str, topic: str) -> List[Dict]:
"""Génère des exercices adaptés"""
profile = self.student_profiles.get(student_id, {})
level = profile.get('current_level', 'beginner')
prompt = f"""Crée 3 exercices de niveau {level} sur "{topic}" :
Types d'exercices variés :
1. Question à choix multiples
2. Exercice pratique/code
3. Question ouverte de réflexion
Chaque exercice doit avoir :
- Énoncé clair
- Difficulté progressive
- Solution détaillée
- Points clés à retenir
Format JSON avec liste d'exercices.
Exercices :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-instruct",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.8,
"max_tokens": 600
}
)
try:
return json.loads(response.json()['choices'][0]['message']['content'])
except:
return []
def _update_student_progress(self, student_id: str, topic: str, assessment: Dict):
"""Met à jour le progrès de l'étudiant"""
if student_id in self.student_profiles:
profile = self.student_profiles[student_id]
# Enregistrer le progrès
profile['progress'][topic] = {
'assessment': assessment,
'timestamp': datetime.now().isoformat(),
'mastery_level': assessment.get('niveau_maitrise', 'débutant')
}
# Mettre à jour les forces et faiblesses
if assessment.get('points_forts'):
profile['strengths'] = list(set(profile['strengths'] + assessment['points_forts']))
if assessment.get('lacunes'):
profile['weaknesses'] = list(set(profile['weaknesses'] + assessment['lacunes']))
# Ajuster le niveau général si nécessaire
self._adjust_student_level(student_id)
def _adjust_student_level(self, student_id: str):
"""Ajuste le niveau de l'étudiant basé sur ses progrès"""
profile = self.student_profiles[student_id]
progress = profile['progress']
if not progress:
return
# Calculer le niveau moyen
levels = {'débutant': 1, 'intermédiaire': 2, 'avancé': 3}
total_score = sum(
levels.get(p['mastery_level'], 1) for p in progress.values()
)
avg_level = total_score / len(progress)
if avg_level >= 2.5:
profile['current_level'] = 'avancé'
elif avg_level >= 1.5:
profile['current_level'] = 'intermédiaire'
else:
profile['current_level'] = 'débutant'
def _estimate_duration(self, pace: str, content_length: int) -> str:
"""Estime la durée d'une leçon"""
base_minutes = content_length // 50 # ~50 caractères par minute de lecture
multipliers = {'slow': 1.5, 'medium': 1.0, 'fast': 0.7}
final_minutes = int(base_minutes * multipliers.get(pace, 1.0))
return f"{final_minutes} minutes"
def _get_prerequisites(self, topic: str) -> List[str]:
"""Retourne les prérequis pour un sujet"""
prerequisites_map = {
'Variables et types de données': [],
'Structures de contrôle': ['Variables et types de données'],
'Fonctions': ['Variables et types de données', 'Structures de contrôle'],
'Classes et objets': ['Fonctions', 'Listes et dictionnaires']
}
return prerequisites_map.get(topic, [])
def _suggest_next_topics(self, student_id: str, current_topic: str) -> List[str]:
"""Suggère les prochains sujets à étudier"""
# Logique simple basée sur le curriculum
# Dans un vrai système, ce serait plus sophistiqué
next_topics_map = {
'Variables et types de données': ['Structures de contrôle'],
'Structures de contrôle': ['Fonctions', 'Listes et dictionnaires'],
'Fonctions': ['Classes et objets', 'Gestion des erreurs']
}
return next_topics_map.get(current_topic, [])
def _extract_milestones(self, subject: str, weeks: int) -> List[Dict]:
"""Extrait les jalons d'un plan d'étude"""
milestones_per_week = weeks // 3 # Un jalon toutes les 3 semaines environ
return [
{
'week': i * 3 + 1,
'title': f'Jalon {i + 1}',
'description': f'Évaluation intermédiaire {i + 1}'
}
for i in range(milestones_per_week)
]
def _get_adaptive_elements(self, student_id: str) -> List[str]:
"""Retourne les éléments adaptatifs du plan"""
return [
'Ajustement automatique de la difficulté',
'Révisions personnalisées selon les faiblesses',
'Accélération possible selon les progrès',
'Support supplémentaire si nécessaire'
]
# Démonstration du tuteur adaptatif
def demo_adaptive_tutor():
tutor = AdaptiveTutor("your-yodi-api-key")
# Créer un profil étudiant
student_id = "student_001"
initial_assessment = {
'learning_style': 'kinesthetic', # visuel, auditif, kinesthésique
'pace': 'medium',
'subjects': ['python_basics'],
'level': 'beginner'
}
tutor.create_student_profile(student_id, initial_assessment)
# Générer une leçon personnalisée
lesson = tutor.generate_personalized_lesson(student_id, 'Variables et types de données')
print("📚 Leçon personnalisée générée :")
print(f"Sujet : {lesson['topic']}")
print(f"Durée estimée : {lesson['estimated_duration']}")
print(f"Contenu :\n{lesson['content'][:500]}...")
# Simuler une réponse d'exercice
student_answer = "Une variable en Python est un nom qui pointe vers une valeur. Par exemple : x = 5"
correct_answer = "Une variable est un nom symbolique qui référence ou pointe vers un objet en mémoire"
feedback = tutor.provide_feedback(student_id, student_answer, correct_answer, 'Variables et types de données')
print(f"\n💬 Feedback personnalisé :\n{feedback}")
# Générer un plan d'étude
study_plan = tutor.generate_study_plan(student_id, 'python_basics', 'intermediate', 8)
print(f"\n📋 Plan d'étude (8 semaines) :\n{study_plan['plan'][:500]}...")
# demo_adaptive_tutor()
📈 Analyste financier intelligent
Système d'analyse de marché
class FinancialAnalyst:
def __init__(self, yodi_api_key: str):
self.yodi_api_key = yodi_api_key
self.base_url = "https://api.yodi.tg/v1"
self.headers = {
"Authorization": f"Bearer {yodi_api_key}",
"Content-Type": "application/json"
}
# Simulation de données de marché
self.market_data = {}
self.news_feed = []
self.portfolio_data = {}
def analyze_stock_sentiment(self, symbol: str, news_articles: List[str]) -> Dict:
"""Analyse le sentiment du marché pour un titre"""
combined_news = '\n'.join(news_articles)
prompt = f"""Analyse le sentiment des actualités pour l'action {symbol} :
Actualités récentes :
{combined_news}
Évalue :
1. Sentiment global (très négatif à très positif, -2 à +2)
2. Facteurs positifs identifiés
3. Risques et préoccupations
4. Impact potentiel sur le cours (court/moyen/long terme)
5. Recommandation (vendre/conserver/acheter)
6. Niveau de confiance de l'analyse (0-100%)
Considère :
- Événements corporatifs
- Tendances sectorielles
- Contexte économique global
- Sentiment des investisseurs
Format JSON avec analyse détaillée.
Analyse :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-1",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.4,
"max_tokens": 500
}
)
try:
return json.loads(response.json()['choices'][0]['message']['content'])
except:
return {'error': 'Erreur lors de l\'analyse'}
def generate_portfolio_recommendations(self, portfolio: Dict, market_conditions: Dict,
risk_tolerance: str, investment_horizon: str) -> Dict:
"""Génère des recommandations de portefeuille"""
prompt = f"""Analyse ce portefeuille et fournis des recommandations personnalisées :
Portefeuille actuel :
{json.dumps(portfolio, indent=2)}
Conditions de marché :
{json.dumps(market_conditions, indent=2)}
Profil investisseur :
- Tolérance au risque : {risk_tolerance}
- Horizon d'investissement : {investment_horizon}
Fournis :
1. Analyse de la diversification actuelle
2. Identification des déséquilibres
3. Recommandations d'allocation d'actifs
4. Titres spécifiques à considérer
5. Stratégies de rébalancement
6. Gestion des risques
7. Objectifs de performance réalistes
Recommendations :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-1",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.5,
"max_tokens": 800
}
)
return {
'analysis': response.json()['choices'][0]['message']['content'],
'timestamp': datetime.now().isoformat(),
'risk_score': self._calculate_portfolio_risk(portfolio),
'diversification_score': self._calculate_diversification(portfolio)
}
def analyze_financial_report(self, company: str, financial_data: Dict) -> Dict:
"""Analyse un rapport financier"""
prompt = f"""Analyse ce rapport financier pour {company} :
Données financières :
{json.dumps(financial_data, indent=2)}
Fournis une analyse complète incluant :
1. Santé financière globale
2. Analyse de rentabilité (marges, ROE, ROA)
3. Analyse de liquidité (ratios current, quick)
4. Analyse d'endettement (debt-to-equity, coverage)
5. Analyse de croissance (revenus, bénéfices)
6. Comparaison sectorielle
7. Points forts et faiblesses
8. Signaux d'alerte éventuels
9. Perspectives d'avenir
10. Note globale (/10) et justification
Sois objectif et factuel dans ton analyse.
Analyse :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-1",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.3,
"max_tokens": 700
}
)
return {
'company': company,
'analysis': response.json()['choices'][0]['message']['content'],
'financial_data': financial_data,
'analysis_date': datetime.now().isoformat()
}
def generate_market_report(self, market_data: Dict, economic_indicators: Dict) -> str:
"""Génère un rapport de marché complet"""
prompt = f"""Crée un rapport de marché professionnel basé sur ces données :
Données de marché :
{json.dumps(market_data, indent=2)}
Indicateurs économiques :
{json.dumps(economic_indicators, indent=2)}
Structure du rapport :
1. Résumé exécutif
2. Vue d'ensemble des marchés
3. Performance sectorielle
4. Analyse des indicateurs économiques
5. Facteurs de risque
6. Opportunités identifiées
7. Perspectives à court et moyen terme
8. Recommandations stratégiques
Ton : professionnel, objectif, basé sur les données
Longueur : rapport complet mais concis
Rapport :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-1",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.4,
"max_tokens": 1000
}
)
return response.json()['choices'][0]['message']['content']
def risk_assessment(self, investment_proposal: Dict) -> Dict:
"""Évalue les risques d'un investissement"""
prompt = f"""Évalue les risques de cette proposition d'investissement :
Proposition :
{json.dumps(investment_proposal, indent=2)}
Analyse des risques selon ces catégories :
1. Risque de marché (volatilité, corrélations)
2. Risque de crédit (solvabilité, rating)
3. Risque de liquidité (facilité de vente)
4. Risque opérationnel (gestion, gouvernance)
5. Risque réglementaire (changements légaux)
6. Risque géopolitique (instabilité politique)
7. Risque de change (exposition devises)
8. Risque de taux d'intérêt
Pour chaque risque :
- Probabilité (faible/moyen/élevé)
- Impact potentiel (1-10)
- Mesures d'atténuation suggérées
Score de risque global (1-10) et recommandation.
Format JSON structuré.
Évaluation :"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers=self.headers,
json={
"model": "yodi-instruct",
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.2,
"max_tokens": 600
}
)
try:
risk_analysis = json.loads(response.json()['choices'][0]['message']['content'])
# Ajouter des métriques calculées
risk_analysis['assessment_date'] = datetime.now().isoformat()
risk_analysis['methodology'] = 'IA-driven qualitative and quantitative analysis'
return risk_analysis
except:
return {'error': 'Erreur lors de l\'évaluation des risques'}
def _calculate_portfolio_risk(self, portfolio: Dict) -> float:
"""Calcule un score de risque du portefeuille"""
# Simulation simple - dans un vrai système, utiliser des modèles financiers
risk_weights = {
'stocks': 0.8,
'bonds': 0.3,
'crypto': 1.0,
'cash': 0.0,
'commodities': 0.6
}
total_value = sum(portfolio.values())
weighted_risk = sum(
(value / total_value) * risk_weights.get(asset_type, 0.5)
for asset_type, value in portfolio.items()
)
return round(weighted_risk, 2)
def _calculate_diversification(self, portfolio: Dict) -> float:
"""Calcule un score de diversification"""
# Calcul simple basé sur la concentration
total_value = sum(portfolio.values())
if total_value == 0:
return 0
# Coefficient de Gini inversé pour mesurer la diversification
proportions = [value / total_value for value in portfolio.values()]
n = len(proportions)
if n <= 1:
return 0
# Score de diversification (plus proche de 1 = mieux diversifié)
concentration = sum(p**2 for p in proportions)
diversification_score = (1 - concentration) * (n / (n - 1))
return round(min(1.0, diversification_score), 2)
# Démonstration de l'analyste financier
def demo_financial_analyst():
analyst = FinancialAnalyst("your-yodi-api-key")
# Analyse de sentiment
news_articles = [
"Apple annonce des résultats trimestriels dépassant les attentes avec une croissance de 15% des ventes d'iPhone.",
"Les analystes relèvent leurs objectifs de cours pour Apple suite aux excellents résultats.",
"Préoccupations concernant la dépendance d'Apple au marché chinois dans un contexte de tensions commerciales."
]
sentiment = analyst.analyze_stock_sentiment("AAPL", news_articles)
print("📈 Analyse de sentiment pour AAPL :")
print(json.dumps(sentiment, indent=2))
# Analyse de portefeuille
portfolio = {
'stocks': 150000,
'bonds': 50000,
'crypto': 10000,
'cash': 15000
}
market_conditions = {
'market_trend': 'bullish',
'volatility': 'medium',
'interest_rates': 'rising',
'inflation': 'moderate'
}
recommendations = analyst.generate_portfolio_recommendations(
portfolio, market_conditions, 'moderate', 'long_term'
)
print("\n💼 Recommandations de portefeuille :")
print(f"Score de risque : {recommendations['risk_score']}")
print(f"Score de diversification : {recommendations['diversification_score']}")
print(f"Analyse :\n{recommendations['analysis'][:500]}...")
# demo_financial_analyst()
Ces exemples montrent comment utiliser l'API YODI pour créer des applications intelligentes dans différents domaines. Chaque cas d'usage combine plusieurs fonctionnalités de l'API pour créer des solutions complètes et personnalisées.