Exemples Python
Cette section présente des exemples pratiques d'utilisation de l'API YODI avec Python pour différents cas d'usage.
Installation et configuration​
pip install yodi-sdk requests python-dotenv
# Configuration de base
import os
from dotenv import load_dotenv
from yodi import Client
load_dotenv()
client = Client(api_key=os.getenv("YODI_API_KEY"))
🤖 Chat et conversation​
Chat simple​
def simple_chat():
"""Exemple de chat simple avec YODI"""
response = client.chat.completions.create(
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
)
return response.choices[0].message.content
print(simple_chat())
Conversation interactive​
class ChatBot:
def __init__(self, system_prompt="Tu es un assistant IA serviable."):
self.messages = [{"role": "system", "content": system_prompt}]
self.client = client
def chat(self, user_message):
"""Envoie un message et reçoit une réponse"""
self.messages.append({"role": "user", "content": user_message})
response = self.client.chat.completions.create(
model="yodi-1",
messages=self.messages,
temperature=0.7,
max_tokens=300
)
assistant_message = response.choices[0].message.content
self.messages.append({"role": "assistant", "content": assistant_message})
return assistant_message
def get_conversation_history(self):
"""Retourne l'historique de la conversation"""
return [msg for msg in self.messages if msg["role"] != "system"]
def clear_history(self):
"""Efface l'historique en gardant le prompt système"""
system_msg = self.messages[0] if self.messages[0]["role"] == "system" else None
self.messages = [system_msg] if system_msg else []
# Utilisation
bot = ChatBot("Tu es un expert en programmation Python.")
while True:
user_input = input("Vous: ")
if user_input.lower() in ['quit', 'exit', 'bye']:
break
response = bot.chat(user_input)
print(f"Bot: {response}")
Chat avec personnalité​
def create_personality_bot(personality_type):
"""Crée un bot avec une personnalité spécifique"""
personalities = {
"professeur": {
"system": "Tu es un professeur patient et pédagogique. Tu expliques les concepts clairement avec des exemples.",
"temperature": 0.3
},
"comedien": {
"system": "Tu es un humoriste. Tu réponds toujours avec humour et légèreté, en faisant des jeux de mots.",
"temperature": 1.2
},
"philosophe": {
"system": "Tu es un philosophe. Tu poses des questions profondes et invites à la réflexion.",
"temperature": 0.8
},
"scientist": {
"system": "Tu es un scientifique rigoureux. Tu donnes des réponses factuelles et cites tes sources.",
"temperature": 0.2
}
}
config = personalities.get(personality_type, personalities["professeur"])
def chat_with_personality(user_message):
response = client.chat.completions.create(
model="yodi-1",
messages=[
{"role": "system", "content": config["system"]},
{"role": "user", "content": user_message}
],
temperature=config["temperature"],
max_tokens=400
)
return response.choices[0].message.content
return chat_with_personality
# Utilisation
comedian_bot = create_personality_bot("comedien")
print(comedian_bot("Pourquoi les ordinateurs sont-ils si lents ?"))
scientist_bot = create_personality_bot("scientist")
print(scientist_bot("Comment fonctionne la photosynthèse ?"))
📝 Génération de contenu​
Générateur d'articles de blog​
def generate_blog_post(topic, keywords, tone="professionnel", length="moyen"):
"""Génère un article de blog optimisé"""
length_configs = {
"court": {"max_tokens": 500, "sections": 3},
"moyen": {"max_tokens": 1000, "sections": 4},
"long": {"max_tokens": 1500, "sections": 5}
}
config = length_configs.get(length, length_configs["moyen"])
prompt = f"""Écris un article de blog {tone} sur le sujet : {topic}
Mots-clés à intégrer naturellement : {', '.join(keywords)}
Structure requise :
1. Titre accrocheur
2. Introduction qui pose le problème
3. {config['sections']} sections principales avec sous-titres
4. Conclusion avec appel Ă l'action
Ton : {tone}
Style : Engageant et informatif
Optimisation SEO : Intégrer les mots-clés naturellement
Article :"""
response = client.chat.completions.create(
model="yodi-1",
messages=[{"role": "user", "content": prompt}],
temperature=0.7,
max_tokens=config["max_tokens"]
)
return response.choices[0].message.content
# Utilisation
article = generate_blog_post(
topic="Intelligence artificielle dans le e-commerce",
keywords=["IA", "e-commerce", "personnalisation", "conversion"],
tone="professionnel",
length="moyen"
)
print(article)
Générateur de contenu marketing​
class MarketingContentGenerator:
def __init__(self):
self.client = client
def generate_product_description(self, product_name, features, target_audience):
"""Génère une description de produit"""
prompt = f"""Crée une description de produit persuasive pour :
Produit : {product_name}
Caractéristiques : {', '.join(features)}
Public cible : {target_audience}
La description doit :
- Mettre en avant les bénéfices
- Créer du désir
- Être optimisée pour la conversion
- Faire 100-150 mots
Description :"""
response = self.client.chat.completions.create(
model="yodi-1",
messages=[{"role": "user", "content": prompt}],
temperature=0.8,
max_tokens=300
)
return response.choices[0].message.content
def generate_email_subject_lines(self, campaign_theme, count=10):
"""Génère des lignes d'objet d'email"""
prompt = f"""Génère {count} lignes d'objet d'email accrocheuses pour une campagne sur : {campaign_theme}
Critères :
- Maximum 50 caractères
- Créer de la curiosité
- Éviter les mots spam
- Varier les approches (urgence, bénéfice, question, etc.)
Lignes d'objet :"""
response = self.client.chat.completions.create(
model="yodi-1",
messages=[{"role": "user", "content": prompt}],
temperature=1.0,
max_tokens=400
)
return response.choices[0].message.content.split('\n')
def generate_social_media_posts(self, content_theme, platforms):
"""Génère des posts pour différents réseaux sociaux"""
posts = {}
platform_configs = {
"twitter": {"char_limit": 280, "hashtags": 3, "tone": "concis"},
"linkedin": {"char_limit": 1300, "hashtags": 5, "tone": "professionnel"},
"instagram": {"char_limit": 2200, "hashtags": 10, "tone": "visuel et engageant"},
"facebook": {"char_limit": 500, "hashtags": 3, "tone": "conversationnel"}
}
for platform in platforms:
if platform not in platform_configs:
continue
config = platform_configs[platform]
prompt = f"""Crée un post {platform} sur : {content_theme}
Contraintes :
- Maximum {config['char_limit']} caractères
- Ton {config['tone']}
- Inclure {config['hashtags']} hashtags pertinents
- Optimisé pour l'engagement
Post {platform} :"""
response = self.client.chat.completions.create(
model="yodi-1",
messages=[{"role": "user", "content": prompt}],
temperature=0.9,
max_tokens=200
)
posts[platform] = response.choices[0].message.content
return posts
# Utilisation
marketing_gen = MarketingContentGenerator()
# Description de produit
description = marketing_gen.generate_product_description(
product_name="Écouteurs sans fil ProSound",
features=["RĂ©duction de bruit", "Autonomie 30h", "RĂ©sistant Ă l'eau", "Son HD"],
target_audience="Professionnels urbains actifs"
)
print("Description produit :", description)
# Posts réseaux sociaux
posts = marketing_gen.generate_social_media_posts(
content_theme="Lancement de notre nouvelle collection Ă©co-responsable",
platforms=["twitter", "linkedin", "instagram"]
)
for platform, post in posts.items():
print(f"\n{platform.upper()} :")
print(post)
🔍 Analyse et recherche​
Analyseur de sentiment​
def analyze_sentiment(text):
"""Analyse le sentiment d'un texte"""
prompt = f"""Analyse le sentiment du texte suivant et fournis :
1. Sentiment global (positif/négatif/neutre)
2. Score de confiance (0-100%)
3. Émotions principales détectées
4. Justification de l'analyse
Texte Ă analyser : "{text}"
Analyse :"""
response = client.chat.completions.create(
model="yodi-1",
messages=[{"role": "user", "content": prompt}],
temperature=0.3,
max_tokens=300
)
return response.choices[0].message.content
# Exemple
avis_client = "Ce produit est absolument fantastique ! Le service client est réactif et la livraison a été rapide. Je recommande vivement !"
print(analyze_sentiment(avis_client))
Extracteur d'informations​
import json
def extract_information(text, schema):
"""Extrait des informations structurées d'un texte"""
schema_str = json.dumps(schema, indent=2)
prompt = f"""Extrait les informations suivantes du texte et retourne-les au format JSON :
Schéma requis :
{schema_str}
Texte Ă analyser :
{text}
Instructions :
- Retourne uniquement le JSON valide
- Si une information n'est pas trouvée, utilise null
- Respecte exactement le schéma fourni
JSON :"""
response = client.chat.completions.create(
model="yodi-instruct", # Modèle optimisé pour les tâches structurées
messages=[{"role": "user", "content": prompt}],
temperature=0.1,
max_tokens=500
)
try:
return json.loads(response.choices[0].message.content)
except json.JSONDecodeError:
return {"error": "Impossible de parser le JSON", "raw_response": response.choices[0].message.content}
# Exemple
email_text = """
De: jean.dupont@email.com
Ă€: support@entreprise.com
Objet: Problème de facturation
Bonjour,
Je vous écris concernant ma facture n°INV-2024-001 d'un montant de 250€
datée du 15 janvier 2024. Il semble y avoir une erreur car j'ai été
facturé deux fois pour le même service.
Pourriez-vous vérifier et me contacter au 06.12.34.56.78 ?
Cordialement,
Jean Dupont
"""
schema = {
"expediteur": "string",
"destinataire": "string",
"sujet": "string",
"numero_facture": "string",
"montant": "number",
"date_facture": "string",
"telephone": "string",
"type_probleme": "string"
}
info_extraite = extract_information(email_text, schema)
print(json.dumps(info_extraite, indent=2, ensure_ascii=False))
Résumeur de documents​
def summarize_document(text, summary_type="bullet_points", max_length=200):
"""Résume un document selon différents formats"""
summary_formats = {
"bullet_points": "sous forme de points clés numérotés",
"paragraph": "en un paragraphe cohérent",
"executive": "comme un résumé exécutif pour dirigeants",
"technical": "en résumé technique avec terminologie spécialisée"
}
format_instruction = summary_formats.get(summary_type, summary_formats["bullet_points"])
prompt = f"""RĂ©sume le document suivant {format_instruction}.
Le résumé doit :
- Faire maximum {max_length} mots
- Capturer les points essentiels
- ĂŠtre clair et concis
- Conserver les informations importantes
Document à résumer :
{text}
Résumé :"""
response = client.chat.completions.create(
model="yodi-1",
messages=[{"role": "user", "content": prompt}],
temperature=0.3,
max_tokens=max_length * 2 # Approximation tokens/mots
)
return response.choices[0].message.content
# Exemple
long_document = """
L'intelligence artificielle (IA) 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. L'analyse prédictive aide à anticiper
la demande et réduire les ruptures de stock.
Cependant, l'implémentation de l'IA nécessite des investissements importants en
infrastructure et formation. Les préoccupations concernant la confidentialité des
données et l'éthique de l'IA restent des défis majeurs.
L'avenir du e-commerce sera probablement dominé par des expériences hyper-personnalisées
alimentées par l'IA, avec des assistants virtuels capables de comprendre et anticiper
les besoins des clients.
"""
resume_executif = summarize_document(long_document, "executive", 150)
print("Résumé exécutif :", resume_executif)
resume_points = summarize_document(long_document, "bullet_points", 100)
print("\nPoints clés :", resume_points)
🔍 Recherche sémantique avec embeddings​
Moteur de recherche simple​
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
class SimpleSearchEngine:
def __init__(self):
self.documents = []
self.embeddings = []
self.client = client
def add_documents(self, documents):
"""Ajoute des documents Ă l'index"""
self.documents.extend(documents)
# Créer les embeddings
response = self.client.embeddings.create(
model="yodi-embed",
input=documents
)
new_embeddings = [item.embedding for item in response.data]
self.embeddings.extend(new_embeddings)
def search(self, query, top_k=5):
"""Recherche les documents les plus similaires"""
if not self.embeddings:
return []
# Créer l'embedding de la requête
query_response = self.client.embeddings.create(
model="yodi-embed",
input=query
)
query_embedding = query_response.data[0].embedding
# Calculer les similarités
similarities = cosine_similarity(
[query_embedding],
self.embeddings
)[0]
# Trier par similarité décroissante
sorted_indices = np.argsort(similarities)[::-1]
results = []
for i in sorted_indices[:top_k]:
results.append({
'document': self.documents[i],
'similarity': similarities[i],
'index': i
})
return results
# Utilisation
search_engine = SimpleSearchEngine()
# Ajouter des documents
documents = [
"L'intelligence artificielle transforme le commerce en ligne avec des recommandations personnalisées.",
"Les chatbots automatisent le service client et réduisent les coûts opérationnels.",
"L'analyse prédictive permet d'optimiser les stocks et d'anticiper la demande.",
"La sécurité des données est cruciale dans les applications d'IA.",
"Les algorithmes de machine learning améliorent la détection de fraude.",
"L'expérience utilisateur est personnalisée grâce aux données comportementales.",
"L'automatisation des processus métier augmente l'efficacité opérationnelle."
]
search_engine.add_documents(documents)
# Effectuer des recherches
query = "Comment l'IA améliore-t-elle l'expérience client ?"
results = search_engine.search(query, top_k=3)
print(f"Recherche : {query}\n")
for i, result in enumerate(results, 1):
print(f"{i}. Similarité: {result['similarity']:.3f}")
print(f" Document: {result['document']}\n")
Système de recommandation​
class ContentRecommender:
def __init__(self):
self.articles = []
self.article_embeddings = []
self.user_profiles = {}
def add_articles(self, articles):
"""Ajoute des articles Ă la base"""
self.articles.extend(articles)
# Créer les embeddings des articles
titles_and_content = [f"{article['title']} {article['content']}" for article in articles]
response = client.embeddings.create(
model="yodi-embed",
input=titles_and_content
)
new_embeddings = [item.embedding for item in response.data]
self.article_embeddings.extend(new_embeddings)
def create_user_profile(self, user_id, liked_articles_indices, interaction_weights=None):
"""Crée un profil utilisateur basé sur ses interactions"""
if not interaction_weights:
interaction_weights = [1.0] * len(liked_articles_indices)
# Moyenne pondérée des embeddings des articles aimés
liked_embeddings = [self.article_embeddings[i] for i in liked_articles_indices]
weighted_embedding = np.average(
liked_embeddings,
axis=0,
weights=interaction_weights
)
self.user_profiles[user_id] = weighted_embedding
def recommend_articles(self, user_id, exclude_seen=True, top_k=5):
"""Recommande des articles Ă un utilisateur"""
if user_id not in self.user_profiles:
return []
user_profile = self.user_profiles[user_id]
# Calculer les similarités
similarities = cosine_similarity(
[user_profile],
self.article_embeddings
)[0]
# Créer la liste des recommandations
recommendations = []
for i, similarity in enumerate(similarities):
recommendations.append({
'article': self.articles[i],
'similarity': similarity,
'index': i
})
# Trier par similarité décroissante
recommendations.sort(key=lambda x: x['similarity'], reverse=True)
return recommendations[:top_k]
# Utilisation
recommender = ContentRecommender()
# Articles exemple
articles = [
{
"title": "Guide complet de l'IA générative",
"content": "L'IA générative révolutionne la création de contenu avec des modèles comme GPT et DALL-E.",
"category": "tech"
},
{
"title": "Optimisation SEO avec l'IA",
"content": "Comment utiliser l'intelligence artificielle pour améliorer votre référencement naturel.",
"category": "marketing"
},
{
"title": "Sécurité des applications IA",
"content": "Les meilleures pratiques pour sécuriser vos applications d'intelligence artificielle.",
"category": "security"
},
{
"title": "Machine Learning pour débutants",
"content": "Introduction aux concepts fondamentaux du machine learning et de l'apprentissage automatique.",
"category": "education"
},
{
"title": "Éthique de l'IA en entreprise",
"content": "Comment intégrer des considérations éthiques dans le développement d'applications IA.",
"category": "ethics"
}
]
recommender.add_articles(articles)
# Créer un profil utilisateur (a aimé les articles 0 et 1)
recommender.create_user_profile("user123", [0, 1], [1.0, 0.8])
# Obtenir des recommandations
recommendations = recommender.recommend_articles("user123", top_k=3)
print("Recommandations pour user123:\n")
for i, rec in enumerate(recommendations, 1):
print(f"{i}. {rec['article']['title']}")
print(f" Similarité: {rec['similarity']:.3f}")
print(f" Catégorie: {rec['article']['category']}\n")
🛠️ Utilitaires et helpers​
Gestionnaire de contexte intelligent​
class ContextManager:
def __init__(self, max_tokens=6000):
self.max_tokens = max_tokens
self.conversation_history = []
def estimate_tokens(self, text):
"""Estimation approximative du nombre de tokens"""
return len(text.split()) * 1.3
def add_message(self, role, content):
"""Ajoute un message Ă l'historique"""
message = {"role": role, "content": content}
self.conversation_history.append(message)
self._optimize_context()
def _optimize_context(self):
"""Optimise le contexte pour rester sous la limite"""
# Garder toujours le message système s'il existe
system_messages = [msg for msg in self.conversation_history if msg["role"] == "system"]
other_messages = [msg for msg in self.conversation_history if msg["role"] != "system"]
# Calculer les tokens actuels
total_tokens = sum(self.estimate_tokens(msg["content"]) for msg in self.conversation_history)
# Supprimer les anciens messages si nécessaire
while total_tokens > self.max_tokens and len(other_messages) > 2:
# Supprimer les deux plus anciens messages (user/assistant)
other_messages = other_messages[2:]
total_tokens = sum(
self.estimate_tokens(msg["content"])
for msg in system_messages + other_messages
)
self.conversation_history = system_messages + other_messages
def get_messages(self):
"""Retourne les messages optimisés"""
return self.conversation_history
def clear_except_system(self):
"""Efface tout sauf les messages système"""
self.conversation_history = [
msg for msg in self.conversation_history
if msg["role"] == "system"
]
# Utilisation
context_mgr = ContextManager(max_tokens=4000)
context_mgr.add_message("system", "Tu es un assistant spécialisé en programmation Python.")
# Simulation d'une longue conversation
for i in range(10):
context_mgr.add_message("user", f"Question {i}: Comment faire ceci en Python?")
context_mgr.add_message("assistant", f"Réponse {i}: Voici comment procéder...")
print(f"Messages dans le contexte: {len(context_mgr.get_messages())}")
Batch processor pour économiser les coûts​
import time
from typing import List, Dict, Callable
class BatchProcessor:
def __init__(self, batch_size=10, delay_between_batches=1):
self.batch_size = batch_size
self.delay_between_batches = delay_between_batches
self.pending_requests = []
def add_request(self, request_data):
"""Ajoute une requĂŞte au batch"""
self.pending_requests.append(request_data)
if len(self.pending_requests) >= self.batch_size:
return self.process_batch()
return None
def process_batch(self):
"""Traite le batch actuel"""
if not self.pending_requests:
return []
batch = self.pending_requests[:]
self.pending_requests.clear()
results = []
for request in batch:
try:
if request['type'] == 'chat':
response = client.chat.completions.create(**request['params'])
results.append({
'success': True,
'response': response,
'request_id': request.get('id')
})
elif request['type'] == 'embedding':
response = client.embeddings.create(**request['params'])
results.append({
'success': True,
'response': response,
'request_id': request.get('id')
})
# Petit délai entre les requêtes
time.sleep(0.1)
except Exception as e:
results.append({
'success': False,
'error': str(e),
'request_id': request.get('id')
})
# DĂ©lai entre les batches
time.sleep(self.delay_between_batches)
return results
def flush(self):
"""Force le traitement du batch actuel"""
return self.process_batch()
# Utilisation
processor = BatchProcessor(batch_size=5, delay_between_batches=2)
# Ajouter des requĂŞtes
requests_data = [
{
'id': f'req_{i}',
'type': 'chat',
'params': {
'model': 'yodi-1',
'messages': [{'role': 'user', 'content': f'Question {i}'}],
'max_tokens': 100
}
}
for i in range(12)
]
# Traiter par batches
all_results = []
for req_data in requests_data:
batch_results = processor.add_request(req_data)
if batch_results:
all_results.extend(batch_results)
# Traiter les requĂŞtes restantes
remaining_results = processor.flush()
if remaining_results:
all_results.extend(remaining_results)
print(f"Traité {len(all_results)} requêtes")
for result in all_results[:3]: # Afficher les 3 premiers résultats
print(f"Request {result['request_id']}: {'Success' if result['success'] else 'Failed'}")