Chat Completion

L'endpoint de chat completion permet de créer des conversations naturelles avec l'IA YODI en utilisant un format de messages structuré.

Endpoint

POST https://api.yodi.tg/v1/chat/completions

Format des messages

Les conversations sont représentées comme une série de messages avec différents rôles :

Rôle	Description	Exemple
system	Instructions pour l'IA	"Tu es un assistant serviable"
user	Messages de l'utilisateur	"Bonjour, comment ça va ?"
assistant	Réponses de l'IA	"Bonjour ! Je vais bien, merci."

Paramètres de requête

Paramètres obligatoires

Paramètre	Type	Description
model	string	Identifiant du modèle (ex: "yodi-1")
messages	array	Liste des messages de la conversation

Paramètres optionnels

Paramètre	Type	Défaut	Description
max_tokens	integer	1024	Nombre maximum de tokens à générer
temperature	float	1.0	Contrôle la créativité (0.0-2.0)
top_p	float	1.0	Nucleus sampling (0.0-1.0)
top_k	integer	50	Limite les choix aux k tokens les plus probables
frequency_penalty	float	0.0	Réduit la répétition (-2.0 à 2.0)
presence_penalty	float	0.0	Encourage la nouveauté (-2.0 à 2.0)
stop	array	null	Séquences d'arrêt personnalisées
stream	boolean	false	Streaming des résultats
functions	array	null	Fonctions disponibles pour l'IA
function_call	object	null	Contrôle l'appel de fonctions

Exemples de requête

Conversation simple

curl -X POST "https://api.yodi.tg/v1/chat/completions" \
-H "Authorization: Bearer your_api_key_here" \
-H "Content-Type: application/json" \
-d '{
"model": "yodi-1",
"messages": [
{"role": "system", "content": "Tu es un assistant IA serviable et amical."},
{"role": "user", "content": "Explique-moi ce qu'\''est l'\''intelligence artificielle"}
],
"max_tokens": 200,
"temperature": 0.7
}'

Python SDK

from yodi import Client

client = Client(api_key="your_api_key_here")

response = client.chat.completions.create(
model="yodi-1",
messages=[
{"role": "system", "content": "Tu es un assistant IA serviable et amical."},
{"role": "user", "content": "Explique-moi ce qu'est l'intelligence artificielle"}
],
max_tokens=200,
temperature=0.7
)

print(response.choices[0].message.content)

JavaScript SDK

import { YodiClient } from 'yodi-sdk';

const client = new YodiClient({
apiKey: 'your_api_key_here'
});

const response = await client.chat.completions.create({
model: 'yodi-1',
messages: [
{ role: 'system', content: 'Tu es un assistant IA serviable et amical.' },
{ role: 'user', content: 'Explique-moi ce qu\'est l\'intelligence artificielle' }
],
max_tokens: 200,
temperature: 0.7
});

console.log(response.choices[0].message.content);

Réponse

Structure de la réponse

{
  "message": "SUCCESS",
  "error": false,
  "data": {
    "id": "chatcmpl-abc123",
    "object": "chat.completion",
    "created": 1693574400,
    "model": "yodi-1",
    "choices": [
      {
        "index": 0,
        "message": {
          "role": "assistant",
          "content": "L'intelligence artificielle (IA) est une technologie qui permet aux machines de simuler l'intelligence humaine..."
        },
        "finish_reason": "stop"
      }
    ],
    "usage": {
      "prompt_tokens": 25,
      "completion_tokens": 50,
      "total_tokens": 75
    }
  },
  "status": 200
}

Gestion des conversations

Conversation multi-tours

def chat_conversation():
messages = [
{"role": "system", "content": "Tu es un tuteur en mathématiques."}
]

while True:
user_input = input("Vous: ")
if user_input.lower() == 'quit':
break

messages.append({"role": "user", "content": user_input})

response = client.chat.completions.create(
model="yodi-1",
messages=messages,
max_tokens=200
)

assistant_message = response.choices[0].message.content
print(f"Assistant: {assistant_message}")

messages.append({"role": "assistant", "content": assistant_message})

Gestion de l'historique

class ChatSession:
def __init__(self, system_prompt=None):
self.messages = []
if system_prompt:
self.messages.append({"role": "system", "content": system_prompt})

def add_user_message(self, content):
self.messages.append({"role": "user", "content": content})

def get_response(self, **kwargs):
response = client.chat.completions.create(
model="yodi-1",
messages=self.messages,
**kwargs
)

assistant_message = response.choices[0].message.content
self.messages.append({"role": "assistant", "content": assistant_message})

return assistant_message

def clear_history(self, keep_system=True):
if keep_system and self.messages and self.messages[0]["role"] == "system":
self.messages = [self.messages[0]]
else:
self.messages = []

# Utilisation
chat = ChatSession("Tu es un expert en cuisine française.")
chat.add_user_message("Comment faire une quiche lorraine ?")
response = chat.get_response(temperature=0.7)
print(response)

Streaming

Activation du streaming

response = client.chat.completions.create(
model="yodi-1",
messages=[
{"role": "user", "content": "Raconte-moi une histoire longue"}
],
stream=True,
max_tokens=500
)

for chunk in response:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end='', flush=True)

Gestion du streaming en JavaScript

const response = await client.chat.completions.create({
model: 'yodi-1',
messages: [
{ role: 'user', content: 'Raconte-moi une histoire longue' }
],
stream: true,
max_tokens: 500
});

for await (const chunk of response) {
if (chunk.choices[0]?.delta?.content) {
process.stdout.write(chunk.choices[0].delta.content);
}
}

Appels de fonctions

Définition de fonctions

functions = [
{
"name": "get_weather",
"description": "Obtient la météo pour une ville donnée",
"parameters": {
"type": "object",
"properties": {
"city": {
"type": "string",
"description": "Le nom de la ville"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "L'unité de température"
}
},
"required": ["city"]
}
}
]

Utilisation des fonctions

def handle_function_call(function_call):
if function_call.name == "get_weather":
args = json.loads(function_call.arguments)
# Appeler votre API météo ici
weather_data = get_weather_api(args["city"], args.get("unit", "celsius"))
return json.dumps(weather_data)

response = client.chat.completions.create(
model="yodi-1",
messages=[
{"role": "user", "content": "Quel temps fait-il à Paris ?"}
],
functions=functions,
function_call="auto"
)

message = response.choices[0].message

if message.function_call:
# L'IA veut appeler une fonction
function_response = handle_function_call(message.function_call)

# Continuer la conversation avec le résultat
messages = [
{"role": "user", "content": "Quel temps fait-il à Paris ?"},
message,
{
"role": "function",
"name": message.function_call.name,
"content": function_response
}
]

final_response = client.chat.completions.create(
model="yodi-1",
messages=messages
)

Prompts système avancés

Assistant spécialisé

system_prompts = {
"code_reviewer": """Tu es un expert en révision de code. Analyse le code fourni et donne des conseils sur :
- La qualité du code
- Les bonnes pratiques
- Les améliorations possibles
- La sécurité
Sois constructif et pédagogique.""",

"translator": """Tu es un traducteur professionnel. Traduis le texte donné en conservant :
- Le sens original
- Le style et le ton
- Les nuances culturelles
Indique toujours la langue source et cible.""",

"math_tutor": """Tu es un professeur de mathématiques patient et pédagogique.
- Explique les concepts étape par étape
- Utilise des exemples concrets
- Encourage les questions
- Adapte ton niveau à l'élève"""
}

Contrôle du comportement

def create_specialized_chat(role, personality_traits=None):
base_prompt = system_prompts.get(role, "Tu es un assistant IA serviable.")

if personality_traits:
base_prompt += f"\nTraits de personnalité : {', '.join(personality_traits)}"

return [{"role": "system", "content": base_prompt}]

# Création d'un assistant avec personnalité
messages = create_specialized_chat(
"math_tutor",
["enthousiaste", "utilise des métaphores", "encourage beaucoup"]
)

Cas d'usage avancés

Chat avec mémoire persistante

import json
import os

class PersistentChat:
def __init__(self, session_file="chat_session.json"):
self.session_file = session_file
self.messages = self.load_session()

def load_session(self):
if os.path.exists(self.session_file):
with open(self.session_file, 'r') as f:
return json.load(f)
return []

def save_session(self):
with open(self.session_file, 'w') as f:
json.dump(self.messages, f, indent=2)

def chat(self, user_message):
self.messages.append({"role": "user", "content": user_message})

response = client.chat.completions.create(
model="yodi-1",
messages=self.messages
)

assistant_message = response.choices[0].message.content
self.messages.append({"role": "assistant", "content": assistant_message})

self.save_session()
return assistant_message

Chat avec recherche de contexte

def chat_with_context(user_query, knowledge_base):
# Rechercher des informations pertinentes
relevant_context = search_knowledge_base(user_query, knowledge_base)

system_prompt = f"""Tu es un assistant qui répond en utilisant les informations suivantes :

{relevant_context}

Réponds uniquement basé sur ces informations. Si tu ne trouves pas la réponse, dis-le clairement."""

response = client.chat.completions.create(
model="yodi-1",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_query}
],
temperature=0.3 # Plus déterministe pour les réponses factuelles
)

return response.choices[0].message.content

Optimisation des performances

Gestion de la longueur du contexte

def trim_conversation(messages, max_tokens=3000):
"""Garde les messages récents sous la limite de tokens"""
# Garder toujours le message système
system_msg = [msg for msg in messages if msg["role"] == "system"]
other_msgs = [msg for msg in messages if msg["role"] != "system"]

# Estimation grossière : 1 token ≈ 0.75 mot
current_tokens = sum(len(msg["content"].split()) * 1.33 for msg in messages)

while current_tokens > max_tokens and len(other_msgs) > 2:
# Supprimer les messages les plus anciens (en gardant les 2 derniers)
other_msgs.pop(0)
if other_msgs: # Supprimer aussi la réponse correspondante
other_msgs.pop(0)
current_tokens = sum(len(msg["content"].split()) * 1.33 for msg in system_msg + other_msgs)

return system_msg + other_msgs

Cache de réponses

import hashlib
from functools import lru_cache

@lru_cache(maxsize=100)
def cached_chat_completion(messages_hash, **kwargs):
# Ne pas cacher les paramètres variables comme temperature
stable_kwargs = {k: v for k, v in kwargs.items()
if k not in ['temperature', 'top_p', 'stream']}

return client.chat.completions.create(**stable_kwargs)

def chat_with_cache(messages, **kwargs):
# Créer un hash des messages pour le cache
messages_str = json.dumps(messages, sort_keys=True)
messages_hash = hashlib.md5(messages_str.encode()).hexdigest()

return cached_chat_completion(messages_hash, messages=messages, **kwargs)

Gestion d'erreurs spécifiques

from yodi.exceptions import YodiAPIError

def robust_chat(messages, max_retries=3, **kwargs):
for attempt in range(max_retries):
try:
response = client.chat.completions.create(
model="yodi-1",
messages=messages,
**kwargs
)
return response.choices[0].message.content

except YodiAPIError as e:
if e.status_code == 429: # Rate limit
wait_time = 2 ** attempt # Backoff exponentiel
print(f"Rate limit atteint, attente {wait_time}s...")
time.sleep(wait_time)
elif e.status_code == 400 and "context_length_exceeded" in str(e):
# Raccourcir la conversation
messages = trim_conversation(messages)
print("Contexte raccourci, nouvelle tentative...")
else:
raise e

raise Exception(f"Échec après {max_retries} tentatives")

Prochaines étapes

• Embeddings
• Modèles disponibles
• Exemples pratiques