Introduction aux Agents IA

User: Quelle est la météo à Paris aujourd'hui ?
LLM: Je ne peux pas accéder aux données en temps réel.

User: Quelle est la météo à Paris aujourd'hui ?
Agent:
1. [PENSE] Je dois utiliser l'API météo
2. [AGIT] Appelle weather_api("Paris", "today")
3. [RÉPOND] Il fait 18°C à Paris avec des nuages, 70% d'humidité

# Approche 2020 : Hard-coded
def agent_v1(query):
    if "météo" in query:
        return call_weather_api()
    elif "calcul" in query:
        return call_calculator()
    else:
        return gpt3_response(query)

# Approche 2022 : ReAct pattern
def agent_v2(query):
    thoughts = []
    while not task_complete:
        thought = llm(f"Pensée: {context}")
        action = llm(f"Action: {thought}")
        observation = execute(action)
        thoughts.append((thought, action, observation))
    return final_answer(thoughts)

# Approche 2023 : Frameworks
from langchain.agents import create_react_agent

agent = create_react_agent(
    llm=ChatOpenAI(model="gpt-4"),
    tools=[weather_tool, calculator_tool, search_tool],
    prompt=react_prompt
)

# Approche 2025 : Multi-agents
from crewai import Crew, Agent, Task

researcher = Agent(role="Researcher", tools=[search, scrape])
analyst = Agent(role="Analyst", tools=[pandas, sql])
writer = Agent(role="Writer", tools=[grammar_check])

crew = Crew(agents=[researcher, analyst, writer])
crew.kickoff("Analyse le marché des voitures électriques")

pip install openai python-dotenv

import openai
import json
from datetime import datetime

# Définir les outils disponibles
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "Retourne l'heure actuelle",
            "parameters": {"type": "object", "properties": {}}
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculator",
            "description": "Effectue un calcul mathématique",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "Expression mathématique (ex: '2+2', '10*5')"
                    }
                },
                "required": ["expression"]
            }
        }
    }
]

# Implémenter les fonctions
def get_current_time():
    return datetime.now().strftime("%H:%M:%S")

def calculator(expression):
    try:
        return str(eval(expression))  # ⚠️ Attention en prod !
    except Exception as e:
        return f"Erreur: {str(e)}"

# Mapper les noms de fonctions
function_map = {
    "get_current_time": get_current_time,
    "calculator": calculator
}

# Boucle agent
def run_agent(user_query, max_iterations=5):
    messages = [{"role": "user", "content": user_query}]

    for iteration in range(max_iterations):
        print(f"\n🔄 Itération {iteration + 1}")

        # Appel LLM
        response = openai.chat.completions.create(
            model="gpt-4",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )

        message = response.choices[0].message
        messages.append(message)

        # Si le LLM veut utiliser un outil
        if message.tool_calls:
            for tool_call in message.tool_calls:
                function_name = tool_call.function.name
                arguments = json.loads(tool_call.function.arguments)

                print(f"  🔧 Appelle {function_name}({arguments})")

                # Exécuter la fonction
                function_result = function_map[function_name](**arguments)
                print(f"  ✅ Résultat: {function_result}")

                # Ajouter le résultat aux messages
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "name": function_name,
                    "content": function_result
                })
        else:
            # L'agent a terminé
            print(f"\n💬 Réponse finale: {message.content}")
            return message.content

    return "Limite d'itérations atteinte"

# Test
if __name__ == "__main__":
    run_agent("Quelle heure est-il ? Combien font 15 * 7 ?")

🔄 Itération 1
  🔧 Appelle get_current_time({})
  ✅ Résultat: 14:32:15
  🔧 Appelle calculator({'expression': '15*7'})
  ✅ Résultat: 105

🔄 Itération 2
💬 Réponse finale: Il est 14:32:15 et 15 × 7 = 105.

def search_wikipedia(query: str, max_results: int = 3) -> str:
    """Recherche sur Wikipédia et retourne les résumés."""
    import wikipedia
    wikipedia.set_lang("fr")

    try:
        results = wikipedia.search(query, results=max_results)
        summaries = []
        for result in results:
            try:
                page = wikipedia.page(result, auto_suggest=False)
                summaries.append(f"**{page.title}**\n{page.summary[:300]}...")
            except:
                continue
        return "\n\n".join(summaries)
    except Exception as e:
        return f"Erreur: {str(e)}"

class AgentMemory:
    def __init__(self):
        self.short_term = []  # Messages de la conversation
        self.long_term = {}   # Faits persistants

    def remember(self, key, value):
        """Stocke une information long-terme"""
        self.long_term[key] = value

    def recall(self, key):
        """Récupère une information"""
        return self.long_term.get(key)

    def add_message(self, role, content):
        """Ajoute un message à la conversation"""
        self.short_term.append({"role": role, "content": content})

def agent_loop(query, tools, max_steps=10):
    state = {"query": query, "step": 0, "complete": False}

    while state["step"] < max_steps and not state["complete"]:
        # 1. Observer
        observation = perceive(state)

        # 2. Raisonner
        thought = llm_think(observation)

        # 3. Décider
        action = llm_decide(thought, tools)

        # 4. Agir
        result = execute_action(action)

        # 5. Mettre à jour l'état
        state = update_state(state, result)
        state["step"] += 1

    return state["final_answer"]

customer_agent = Agent(
    llm="gpt-4",
    tools=[
        check_order_status,
        initiate_refund,
        search_knowledge_base,
        escalate_to_human
    ],
    system_prompt="""Tu es un agent de service client.
    1. Identifie le numéro de commande
    2. Vérifie son statut
    3. Résous le problème ou escalade si nécessaire
    """
)

# Exemple
customer_agent.run("Ma commande #12345 n'est pas arrivée")
# → Vérifie le statut → Voit qu'elle est perdue → Initie un remboursement

data_agent = Agent(
    llm="gpt-4",
    tools=[
        execute_sql,
        generate_chart,
        calculate_statistics,
        write_report
    ]
)

data_agent.run("""Analyse les ventes du Q4 2024 :
- Quel produit s'est le mieux vendu ?
- Quelles régions ont surperformé ?
- Crée un graphique et un résumé exécutif""")

# L'agent :
# 1. Écrit et exécute une requête SQL
# 2. Calcule les KPIs
# 3. Génère un graphique
# 4. Rédige un rapport

code_agent = Agent(
    llm="claude-3-opus",
    tools=[
        read_file,
        write_file,
        run_tests,
        search_documentation,
        run_linter
    ]
)

code_agent.run("""Ajoute une validation email
dans le formulaire d'inscription""")

# L'agent :
# 1. Lit le fichier du formulaire
# 2. Recherche les best practices de validation email
# 3. Modifie le code
# 4. Lance les tests
# 5. Corrige les erreurs de linting

"Donne-moi l'heure à Tokyo, le taux EUR/USD actuel,
et dis-moi si c'est un bon moment pour acheter"

User: Mon nom est Alice
Agent: Enchanté Alice !

[30 minutes plus tard]

User: Comment je m'appelle ?
Agent: Tu t'appelles Alice.