🔑 Étape 1 : Obtenir une clé API Claude

Claude d Anthropic est l un des meilleurs modèles d IA pour créer des agents intelligents !

Créer un compte Anthropic

1. Allez sur console.anthropic.com
2. Cliquez sur "Sign Up"
3. Créez votre compte avec votre email
4. Vérifiez votre email
5. Connectez-vous à la console

Obtenir votre clé API

1. Dans la console, cliquez sur "API Keys"
2. Cliquez sur "Create Key"
3. Donnez un nom à votre clé (ex: "Mon Agent IA")
4. Copiez la clé générée (elle commence par sk-ant-)

🐍 Étape 2 : Installer Python et les dépendances

Vérifier Python

Ouvrez un terminal et vérifiez que Python est installé :

python --version
# ou
python3 --version

Vous devriez voir : Python 3.8.x ou supérieur

Créer un projet

# Créer un dossier pour votre agent
mkdir mon-agent-ia
cd mon-agent-ia

# Créer un environnement virtuel
python -m venv venv

# Activer l environnement virtuel
# Sur Windows :
venv\Scripts\activate
# Sur Linux/Mac :
source venv/bin/activate

Installer les bibliothèques

# Installer Anthropic SDK
pip install anthropic

# Installer des outils utiles
pip install python-dotenv requests beautifulsoup4

# Vérifier l installation
pip list

⚙️ Étape 3 : Configuration de base

Créer le fichier .env

Créez un fichier .env à la racine de votre projet :

ANTHROPIC_API_KEY=sk-ant-votre-cle-ici

Créer le fichier .gitignore

Pour ne pas exposer votre clé API :

.env
venv/
__pycache__/
*.pyc

🤖 Étape 4 : Créer votre premier agent simple

Commençons par un agent basique qui peut converser !

Créer agent_simple.py

import os
from anthropic import Anthropic
from dotenv import load_dotenv

# Charger les variables d environnement
load_dotenv()

# Initialiser le client Anthropic
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def chat_with_agent(message):
    """Envoie un message à l agent et retourne sa réponse"""
    
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": message
            }
        ]
    )
    
    return response.content[0].text

# Boucle de conversation
print("🤖 Agent IA démarré ! (tapez exit pour quitter)")
print("-" * 50)

while True:
    user_input = input("\nVous: ")
    
    if user_input.lower() in ["exit", "quit", "bye"]:
        print("👋 Au revoir !")
        break
    
    response = chat_with_agent(user_input)
    print(f"\n🤖 Agent: {response}")

Tester votre agent

python agent_simple.py

🤖 Agent IA démarré ! (tapez exit pour quitter)
--------------------------------------------------

Vous: Bonjour ! Qui es-tu ?

🤖 Agent: Bonjour ! Je suis Claude, un assistant IA créé 
par Anthropic. Je suis là pour vous aider avec diverses 
tâches comme répondre à vos questions, analyser des 
informations, ou vous assister dans vos projets.

Vous: Quelle est la capitale de la France ?

🤖 Agent: La capitale de la France est Paris.

🛠️ Étape 5 : Agent avec outils (Tool Use)

Donnons des super-pouvoirs à notre agent ! Il pourra maintenant utiliser des outils pour accomplir des tâches complexes.

Créer agent_avec_outils.py

import os
import json
import requests
from datetime import datetime
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

# Définir les outils disponibles
tools = [
    {
        "name": "get_weather",
        "description": "Obtient la météo actuelle pour une ville donnée",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Le nom de la ville"
                }
            },
            "required": ["city"]
        }
    },
    {
        "name": "calculate",
        "description": "Effectue un calcul mathématique",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": "L expression mathématique à calculer"
                }
            },
            "required": ["expression"]
        }
    },
    {
        "name": "get_current_time",
        "description": "Obtient l heure et la date actuelles",
        "input_schema": {
            "type": "object",
            "properties": {}
        }
    }
]

# Implémenter les fonctions des outils
def get_weather(city):
    """Simule l obtention de la météo"""
    # Dans un vrai projet, utilisez une vraie API météo
    return {
        "city": city,
        "temperature": "22°C",
        "condition": "Ensoleillé",
        "humidity": "65%"
    }

def calculate(expression):
    """Calcule une expression mathématique"""
    try:
        result = eval(expression)
        return {"result": result}
    except Exception as e:
        return {"error": str(e)}

def get_current_time():
    """Retourne l heure actuelle"""
    now = datetime.now()
    return {
        "date": now.strftime("%d/%m/%Y"),
        "time": now.strftime("%H:%M:%S"),
        "day": now.strftime("%A")
    }

# Mapper les noms d outils aux fonctions
tool_functions = {
    "get_weather": get_weather,
    "calculate": calculate,
    "get_current_time": get_current_time
}

def process_tool_call(tool_name, tool_input):
    """Exécute l outil demandé"""
    if tool_name in tool_functions:
        return tool_functions[tool_name](**tool_input)
    return {"error": "Outil inconnu"}

def chat_with_tools(user_message):
    """Agent qui peut utiliser des outils"""
    
    messages = [{"role": "user", "content": user_message}]
    
    while True:
        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1024,
            tools=tools,
            messages=messages
        )
        
        # Si Claude veut utiliser un outil
        if response.stop_reason == "tool_use":
            # Extraire l appel d outil
            tool_use = next(
                block for block in response.content 
                if block.type == "tool_use"
            )
            
            tool_name = tool_use.name
            tool_input = tool_use.input
            
            print(f"\n🔧 Utilisation de l outil: {tool_name}")
            print(f"   Paramètres: {tool_input}")
            
            # Exécuter l outil
            tool_result = process_tool_call(tool_name, tool_input)
            
            print(f"   Résultat: {tool_result}")
            
            # Ajouter la réponse de Claude et le résultat de l outil
            messages.append({"role": "assistant", "content": response.content})
            messages.append({
                "role": "user",
                "content": [{
                    "type": "tool_result",
                    "tool_use_id": tool_use.id,
                    "content": json.dumps(tool_result)
                }]
            })
        else:
            # Claude a fini, retourner sa réponse
            return response.content[0].text

# Boucle de conversation
print("🤖 Agent IA avec outils démarré !")
print("💡 Essayez: Quelle heure est-il ? / Calcule 25 * 4 / Météo à Paris")
print("-" * 60)

while True:
    user_input = input("\nVous: ")
    
    if user_input.lower() in ["exit", "quit", "bye"]:
        print("👋 Au revoir !")
        break
    
    response = chat_with_tools(user_input)
    print(f"\n🤖 Agent: {response}")

Tester l agent avec outils

python agent_avec_outils.py

Vous: Quelle heure est-il ?

🔧 Utilisation de l outil: get_current_time
   Paramètres: {}
   Résultat: {date: 10/02/2026, time: 14:30:45, day: Tuesday}

🤖 Agent: Il est actuellement 14h30 et 45 secondes. 
Nous sommes mardi, le 10 février 2026.

Vous: Calcule 156 * 23 + 45

🔧 Utilisation de l outil: calculate
   Paramètres: {expression: 156 * 23 + 45}
   Résultat: {result: 3633}

🤖 Agent: Le résultat de 156 × 23 + 45 est 3633.

🌐 Étape 6 : Agent avec recherche web

Donnons à notre agent la capacité de chercher sur Internet !

Ajouter l outil de recherche

Ajoutez cet outil à votre liste tools :

{
    "name": "search_web",
    "description": "Recherche des informations sur Internet",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "La requête de recherche"
            }
        },
        "required": ["query"]
    }
}

Implémenter la fonction

def search_web(query):
    """Recherche sur le web (exemple simplifié)"""
    # Dans un vrai projet, utilisez une API comme SerpAPI ou Brave Search
    
    # Simulation de résultats
    return {
        "query": query,
        "results": [
            {
                "title": f"Résultat pour: {query}",
                "snippet": "Informations pertinentes trouvées...",
                "url": "https://example.com"
            }
        ]
    }

📁 Étape 7 : Agent qui gère des fichiers

Permettons à notre agent de lire et écrire des fichiers !

Outils de gestion de fichiers

def read_file(filename):
    """Lit le contenu d un fichier"""
    try:
        with open(filename, r, encoding=utf-8) as f:
            content = f.read()
        return {"success": True, "content": content}
    except Exception as e:
        return {"success": False, "error": str(e)}

def write_file(filename, content):
    """Écrit du contenu dans un fichier"""
    try:
        with open(filename, w, encoding=utf-8) as f:
            f.write(content)
        return {"success": True, "message": f"Fichier {filename} créé"}
    except Exception as e:
        return {"success": False, "error": str(e)}

def list_files(directory="."):
    """Liste les fichiers d un dossier"""
    try:
        import os
        files = os.listdir(directory)
        return {"success": True, "files": files}
    except Exception as e:
        return {"success": False, "error": str(e)}

Vous: Crée un fichier todo.txt avec ma liste de courses

🔧 Utilisation de l outil: write_file
   Paramètres: {
     filename: todo.txt,
     content: Liste de courses:\n- Lait\n- Pain\n- Œufs
   }

🤖 Agent: J ai créé le fichier todo.txt avec votre 
liste de courses !

Vous: Lis le fichier todo.txt

🔧 Utilisation de l outil: read_file
   Paramètres: {filename: todo.txt}

🤖 Agent: Voici le contenu de todo.txt:
Liste de courses:
- Lait
- Pain
- Œufs

🎯 Cas d usage pratiques

❓ Résolution de problèmes