Prompt Engineering et APIs

Prompt : "Si j''ai 3 paniers de 7 pommes et que j''en mange 4, combien m''en reste-t-il ?"
GPT-4 (sans CoT) : "17" ✓ (parfois correct, parfois non)

Prompt : "Si j''ai 3 paniers de 7 pommes et que j''en mange 4,
         combien m''en reste-t-il ?
         Réfléchis étape par étape."

Réponse :
1. 3 paniers × 7 pommes = 21 pommes au total
2. J''en mange 4
3. 21 - 4 = 17 pommes restantes

messages = [
    {"role": "system", "content": "Tu es un assistant logique. Raisonne toujours étape par étape."},
    {"role": "user", "content": "Marie a 2 fois plus de billes que Jean. Jean a 3 billes de plus que Paul. Paul a 5 billes. Combien Marie a-t-elle de billes ?"},
    {"role": "assistant", "content": """Raisonnons étape par étape :
1. Paul a 5 billes
2. Jean a 3 billes de plus que Paul → 5 + 3 = 8 billes
3. Marie a 2 fois plus que Jean → 8 × 2 = 16 billes

Marie a 16 billes."""},
    {"role": "user", "content": "Un train part à 14h de Paris à 300 km/h. Un autre part à 15h de Lyon (450 km) à 250 km/h vers Paris. À quelle heure se croisent-ils ?"}
]

from openai import OpenAI

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key="sk-or-...")

response = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Tu extrais des informations de CV en JSON."},
        {"role": "user", "content": """Extrais les infos de ce CV :
Jean Dupont, 5 ans d''expérience en Python et React.
Diplômé de l''INSA Lyon en 2019. Parle français et anglais.

Retourne un JSON avec : name, experience_years, skills (array), school, languages (array)"""}
    ],
    response_format={"type": "json_object"},
    temperature=0
)

import json
data = json.loads(response.choices[0].message.content)
print(json.dumps(data, indent=2, ensure_ascii=False))

{
  "name": "Jean Dupont",
  "experience_years": 5,
  "skills": ["Python", "React"],
  "school": "INSA Lyon",
  "languages": ["français", "anglais"]
}

from pydantic import BaseModel
from typing import List

class CVInfo(BaseModel):
    name: str
    experience_years: int
    skills: List[str]
    school: str
    languages: List[str]

# Valider la réponse du LLM
cv = CVInfo(**data)
print(f"Candidat : {cv.name}, {cv.experience_years} ans d''exp.")
print(f"Compétences : {', '.join(cv.skills)}")

import json

# Définir les fonctions disponibles
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtenir la météo actuelle pour une ville",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "Nom de la ville"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Unité de température"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "Chercher des informations sur le web",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "La requête de recherche"
                    }
                },
                "required": ["query"]
            }
        }
    }
]

# Envoyer au LLM
response = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[
        {"role": "user", "content": "Quel temps fait-il à Toulouse ?"}
    ],
    tools=tools,
    tool_choice="auto"  # Le modèle décide s''il appelle une fonction
)

# Le modèle retourne un appel de fonction
message = response.choices[0].message
if message.tool_calls:
    call = message.tool_calls[0]
    print(f"Fonction : {call.function.name}")
    print(f"Arguments : {call.function.arguments}")
    # → Fonction : get_weather
    # → Arguments : {"city": "Toulouse", "unit": "celsius"}

def get_weather(city, unit="celsius"):
    """Simule un appel API météo."""
    # En production, appelez une vraie API
    return {"temp": 18, "condition": "ensoleillé", "city": city}

# 1. Premier appel : le LLM décide d''appeler get_weather
response = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Météo à Toulouse ?"}],
    tools=tools,
)

# 2. Exécuter la fonction
call = response.choices[0].message.tool_calls[0]
args = json.loads(call.function.arguments)
result = get_weather(**args)

# 3. Renvoyer le résultat au LLM pour qu''il formule la réponse
messages = [
    {"role": "user", "content": "Météo à Toulouse ?"},
    response.choices[0].message,  # Le message avec l''appel de fonction
    {
        "role": "tool",
        "tool_call_id": call.id,
        "content": json.dumps(result)
    }
]

final = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=messages,
)
print(final.choices[0].message.content)
# → "Il fait 18°C et ensoleillé à Toulouse."

system_prompt = """Tu es un assistant expert en droit du travail français.

RÈGLES :
- Réponds UNIQUEMENT aux questions de droit du travail français
- Cite les articles de loi pertinents (Code du travail)
- Si tu n''es pas sûr, dis-le explicitement
- Format : commence par un résumé en 1 phrase, puis développe
- Langue : français, registre professionnel

INTERDICTIONS :
- Ne donne jamais de conseil juridique définitif
- Ne réponds pas aux questions hors sujet
- Ajoute toujours : "Consultez un avocat pour votre situation spécifique."
"""

conversation = [
    {"role": "system", "content": "Tu es un tuteur Python patient et pédagogue."},
]

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

    response = client.chat.completions.create(
        model="openai/gpt-4o-mini",
        messages=conversation,
        temperature=0.5
    )

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

    return assistant_message

# Utilisation
print(chat("C''est quoi une liste en Python ?"))
print(chat("Comment en ajouter un élément ?"))  # Se souvient du contexte
print(chat("Et pour en supprimer ?"))            # Historique complet envoyé

# Étape 1 : Extraire les données
extract_response = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": f"Extrais les noms et dates de ce texte en JSON :\n{texte}"}],
    response_format={"type": "json_object"},
    temperature=0
)
data = json.loads(extract_response.choices[0].message.content)

# Étape 2 : Analyser avec les données extraites
analysis_response = client.chat.completions.create(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": f"Analyse ces événements et identifie les tendances :\n{json.dumps(data)}"}],
    temperature=0.3
)
print(analysis_response.choices[0].message.content)

import json
from openai import OpenAI

client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key="sk-or-...")

system = """Tu es un expert en extraction de données produit.
Pour chaque fiche produit, retourne un JSON avec :
- name (string)
- price (number, en euros)
- category (string)
- features (array de strings)
- rating (number, sur 5)
- in_stock (boolean)

Si une information est absente, utilise null."""

fiches = [
    "iPhone 15 Pro - 1229€ - Smartphone Apple. Puce A17 Pro, 256Go, titane. Note 4.7/5. En stock.",
    "Casque Sony WH-1000XM5 - Réduction de bruit active, 30h autonomie, Bluetooth 5.2. 349€. Rupture de stock. 4.8/5.",
    "Samsung Galaxy Tab S9 - Tablette 11 pouces, 128Go, S Pen inclus. Prix : 799€."
]

for fiche in fiches:
    response = client.chat.completions.create(
        model="openai/gpt-4o-mini",
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": fiche}
        ],
        response_format={"type": "json_object"},
        temperature=0
    )
    data = json.loads(response.choices[0].message.content)
    print(json.dumps(data, indent=2, ensure_ascii=False))
    print("---")