Créer un agent IA à partir de zéro est plus facile que vous ne le pensez

Un guide étape par étape pour créer un agent d’IA complet pour l’édition de code avec Python – d’un simple chatbot à un agent qui lit, répertorie et modifie des fichiers à l’aide de LLM

Dans ce blog, nous allons créer à partir de zéro un agent d’IA complet capable de lire des fichiers, de répertorier des répertoires et même de modifier du code en moins de 400 lignes de code Python.

Si vous avez déjà vu un agent IA modifier des fichiers, exécuter des commandes, récupérer des erreurs et réessayer différentes stratégies, il peut sembler qu’il y a une magie profonde derrière cela. Non, c’est un LLM, un cycle et suffisamment de jetons. C’est tout.

J’ai été inspiré par l’excellent article de Torsten Boll dans lequel il construit un agent d’édition de code dans Go. Dans ce blog, je vais vous guider étape par étape dans la création de la même chose en Python à l’aide du SDK Anthropic (pour la sortie LLM). À terme, vous disposerez d’un agent fonctionnel capable de naviguer de manière autonome dans votre système de fichiers et de modifier le code.

Mais avant de plonger dans le vif du sujet, comprenons ce qu’est réellement un agent IA et comment fonctionne l’outil.

Qu’est-ce qu’un agent d’intelligence artificielle ?

Un Agent d’intelligence artificielle c’est juste un LLM avec accès à des outils, ce qui lui donne la possibilité de changer n’importe quoi en dehors de la fenêtre contextuelle.

C’est toute la définition. Décomposons-le :

• Master en droit — Un cerveau qui réfléchit et prend des décisions
• outils — Fonctions que l’agent peut appeler pour interagir avec le monde extérieur (lecture de fichiers, recherche sur le web, exécution de code, etc.)
• Boucle — L’agent continue de s’exécuter jusqu’à ce que la tâche soit terminée, en appelant les outils si nécessaire

En termes simples, pensez-y de cette façon : vous (l’utilisateur) confiez une tâche à un agent. L’agent y réfléchit, décide qu’il a besoin de plus d’informations, appelle un outil pour obtenir ces informations, traite le résultat, décide s’il doit en faire plus et répète jusqu’à ce que la tâche soit terminée. C’est tout le cycle.

Maintenant, construisons-en un.

Conditions préalables

Voici ce que vous devrez suivre :

• Python3.10+ installé
• Clé API anthropique – Obtenez-en un depuis la console anthropique
• Terminal et éditeur de texte

Installez la bibliothèque requise :

pip install anthropic

Définissez la clé API comme variable d’environnement :

export ANTHROPIC_API_KEY="your-api-key-here"

Étape 1 : Créer un chatbot de base

Commençons par un simple. Avant d’ajouter des fonctionnalités d’agent, créons un chatbot de terminal de base qui parle à Claude.

Créez un nouveau fichier appelé agent.py :

імпарт os
імпарт json
ад антропны імпарт Антропны

кліент = Anthropic()

дэф чат():
    """Асноўны цыкл чат-бота - размаўляйце з Клодам у тэрмінале."""
        размова = []
    
        друк("Чат з Клодам (каб выйсці, выкарыстоўвайце 'ctrl-c')")
    
        пакуль Праўда:
        user_input = увод("\033[94mYou\033[0m: ")
        
        # Add user message to conversation
        conversation.append({
            "role": "user",
            "content": user_input
        })
        
        # Send to Claude
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            messages=conversation
        )
        
        # Extract and print response
        assistant_message = response.content[0].тэкст
        друк (ф"\033[93mClaude\033[0m: {assistant_message}")
        
        # Add assistant response to conversation
        conversation.append({
            "role": "assistant",
            "content": response.content
        })

if __name__ == "__main__":
    chat()

Run it:

python agent.py

Chat with Claude (use 'ctrl-c' to quit)
You: Hey! I'm Luv! How are you?
Claude: Hi Luv! I'm doing well, thanks for asking. How are you doing today?
You: What's my name?
Claude: Your name is Luv!

Que se passe-t-il ici ?

1. Nous imprimons une invite et attendons la saisie de l’utilisateur
2. Nous ajoutons le message de l’utilisateur à la liste de conversations
3. Nous envoyons l’intégralité de la conversation à Claude
4. Nous imprimons la réponse de Claude et l’ajoutons à la conversation
5. Répéter

Remarquez comment Claude se souvient de votre nom dès le premier message. C’est parce que nous envoyons le conversation entière à chaque fois. Le serveur (API d’Anthropic) est apatride – il ne voit que le contenu de la liste de conversations que nous envoyons. C’est à nous de maintenir ce contexte.

Il s’agit essentiellement de toutes les applications de chat IA que vous avez déjà utilisées, uniquement dans le terminal. Mais ce n’est pas encore un agent. Changeons cela.

Qu’est-ce que l’utilisation des outils (appel de fonction) ?

Avant d’ajouter des outils à notre agent, comprenons le concept. L’idée de base est la suivante :

Étape 1 : Vous indiquez au modèle quels outils sont disponibles (nom, description, paramètres d’entrée)

Étape 2 : Lorsque le modèle souhaite utiliser un outil, il répond avec un message spécial tool_use au lieu du texte normal

Étape 3 : Vous exécutez l’outil localement et renvoyez le résultat au modèle

Étape 4 : Le modèle utilise ce résultat pour poursuivre sa réponse

En termes simples, imaginez que vous parlez à un ami et que vous lui dites : “Dans la conversation suivante, fais un clin d’œil si tu veux que je lève le bras.” C’est essentiellement ce qu’est l’utilisation des outils : nous définissons des signaux (outils) pour le modèle, et quand il “cligne de l’œil” (demande un outil), nous “levons le bras” (exécutons la fonction) et lui disons ce qui s’est passé.

Nous pouvons déjà démontrer ce concept sans aucune modification de code. Essayez cette conversation dans notre chatbot de base :

You: You are a weather expert. When I ask about weather, reply with 
     get_weather(<location>). I will tell you the actual weather.
Claude: Understood! I'll use get_weather(<location>) when you ask about 
        the weather. Ready when you are.
You: What's the weather in Mumbai?
Claude: get_weather(Mumbai)
You: Hot and humid, 32 degrees celsius
Claude: The current weather in Mumbai is hot and humid at 32°C (about 90°F).
        That's fairly typical for Mumbai. Stay hydrated!

Vous voyez ce qui s’est passé ? Nous avons dit à Claude de « faire un clin d’œil » avec get_weather lorsqu’il veut des données météorologiques. C’est fait, nous avons répondu avec le résultat, et Claude l’a traité naturellement.

Ces modèles sont formés et perfectionnés pour utiliser des outils, ils sont très désireux de le faire. Aujourd’hui, en 2026, ils « savent » essentiellement qu’ils ne savent pas tout et qu’ils peuvent utiliser des outils pour obtenir plus d’informations.

Maintenant, au lieu de le faire manuellement, formalisons-le avec une prise en charge API appropriée.

Étape 2 : Ajouter l’infrastructure d’utilisation des outils

Restructurons notre code pour prendre en charge les outils. Nous allons créer une classe Agent avec la boucle d’agent principale :

import os
import json
from anthropic import Anthropic

client = Anthropic()

class Agent:
    def __init__(self, tools=None):
        self.tools = tools or []
                self.tool_functions = {}
        
        def register_tool(я, імя, апісанне, схема_ўводу, функцыя):
        """Зарэгіструйце інструмент, які можа выкарыстоўваць Клод."""
                self.tools.append({
            "імя": імя,
            "апісанне": апісанне,
            "схема_ўводу": схема_ўводу
        })
        self.tool_functions[name] = функцыя
    
        def execute_tool(сама, імя_інструмента, увод_інструмента):
        """Выканаць інструмент і вярнуць вынік."""
                калі tool_name не ў self.tool_functions:
            вяртанне f"Памылка: інструмент "{tool_name}" не знойдзены"
        
                паспрабуйце:
            вынік = self.tool_functions[tool_name](увод_інструмента)
            вярнуць вынік
        за выключэннем выключэння як e:
            вяртанне f"Памылка: {str(e)}"
    
        дэф запусціць (сам):
        """Цыкл галоўнага агента."""
                размова = []
        
                друк("Чат з Клодам (каб выйсці, выкарыстоўвайце 'ctrl-c')")
        
                пакуль Праўда:
            # Атрымаць увод карыстальніка
            user_input = увод("\033[94mYou\033[0m: ")
            conversation.append({
                "role": "user",
                "content": user_input
            })
            
            # Agent loop - keeps running until no more tool calls
            while True:
                response = client.messages.create(
                    model="claude-sonnet-4-20250514",
                    max_tokens=4096,
                    messages=conversation,
                    tools=self.tools
                )
                
                # Add assistant response to conversation
                conversation.append({
                    "role": "assistant",
                    "content": response.content
                })
                
                # Process response - check for tool use
                tool_results = []
                                для блока ў response.content:
                    калі block.type == "тэкст":
                        друк (ф"\033[93mClaude\033[0m: {block.text}")
                    elif block.type == "tool_use":
                        print(f"\033[92mtool\033[0m: {block.name}({json.dumps(block.input)})")
                        result = self.execute_tool(block.name, block.input)
                        tool_results.append({
                            "type": "tool_result",
                            "tool_use_id": block.id,
                            "content": str(result)
                        })
                
                # If no tool calls, we're done - wait for next user input
                if not tool_results:
                    break
                
                # Send tool results back to Claude
                conversation.append({
                    "role": "user",
                    "content": tool_results
                })

Décomposons l’élément clé : l’intérieur while Vrai boucle :

C’est le battement de cœur de chaque agent IA. Voici ce qui se passe :

1. Envoyer la conversation à Claude (incluant les définitions des outils)
2. Récupérez la réponse
3. Vérifiez chaque bloc de contenu dans la réponse :

• Si c’est du texte → imprimez-le
• Si c’est tool_use → exécutez l’outil, collectez le résultat et ajoutez-le à la liste de conversations

4. Puis la même boucle S’il y a eu des appels d’outils → renvoyer les résultats à Claude et refaire une boucle

5. Si aucun outil n’appelle → Claude a terminé, arrêtez et attendez la prochaine entrée de l’utilisateur

C’est ça. C’est cette boucle interne qui transforme un chatbot en agent. L’agent continue d’appeler les outils et de traiter les résultats jusqu’à ce qu’il décide qu’il dispose de suffisamment d’informations pour vous donner une réponse définitive.

Étape 3 : L’outil read_file

Construisons maintenant notre premier outil : read_file. Cet outil permet à Claude de lire le contenu de n’importe quel fichier du répertoire de travail.

Chaque outil a besoin de quatre choses :

• Nom — Comment l’appeler
• Description— Indique au modèle ce que fait l’outil, quand l’utiliser, quand NE PAS l’utiliser
• Schéma de saisie— Schéma JSON décrivant les entrées attendues par l’outil
• Fonction— L’implémentation réelle qui s’exécute lorsque Claude l’appelle

def read_file(input_data):
    """Read the contents of a file."""
    path = input_data["path"]
    
        паспрабуйце:
        з адкрытым (шляхам, "р") як f:
            вяртанне f.read()
    акрамя FileNotFoundError:
        вяртанне f"Памылка: файл '{path}' не знойдзены"
        за выключэннем выключэння як e:
        вяртанне f"Памылка чытання файла: {str(e)}"

Enregistrez-le auprès de notre agent :

agent = Agent()

agent.register_tool(
    name="read_file",
    description="Read the contents of a given relative file path. Use this when you want to see what's inside a file. Do not use this with directory names.",
    input_schema={
        "type": "object",
        "properties": {
            "path": {
                "type": "string",
                "description": "The relative path of a file in the working directory."
            }
        },
        "required": ["path"]
    },
    function=read_file
)

Vérifions ! Tout d’abord, créez un fichier de test :

echo 'What animal is the most disagreeable because it always says neigh?' > secret-file.txt

Maintenant, démarrez l’agent :

You: Help me solve the riddle in secret-file.txt
tool: read_file({"path": "secret-file.txt"})
Claude: The answer to the riddle is: A horse! 🐴

The riddle plays on the word "neigh" which is the sound a horse 
makes — sounding like "nay", meaning to disagree. So horses are 
"disagreeable" because they always say "neigh/nay"!

Remarquez quelque chose de puissant ici : nous ne l’avons jamais dit à Claude“Lorsque l’utilisateur demande un fichier, lisez le fichier.” Nous n’avons pas non plus dit “si quelque chose ressemble à un nom de fichier, trouvez comment le lire”. On vient de dire “aidez-moi à résoudre un truc dans ce dossier” et Claude je l’ai compris tout seulqu’il doit lire le dossier pour répondre à la question.

C’est la magie de l’utilisation des outils, vous identifiez les capacités et LLM décide quand et comment les utiliser.

Étape 4 : L’outil list_files

Tout bon agent doit naviguer. Tout comme la première chose que vous faites sur un nouveau serveur est d’exécuter ls, donnons à Claude la même opportunité :

import os

def list_files(input_data):
    """List files and directories at a given path."""
    dir_path = input_data.get("path", ".")
    
    try:
        entries = []
        for item in os.listdir(dir_path):
            full_path = os.path.join(dir_path, item)
            if os.path.isdir(full_path):
                entries.append(f"{item}/")
            else:
                entries.append(item)
        return json.dumps(sorted(entries))
    except Exception as e:
        return f"Error listing files: {str(e)}"

agent.register_tool(
    name="list_files",
    description="List files and directories at a given path. If no path is provided, lists files in the current directory.",
    input_schema={
        "type": "object",
        "properties": {
            "path": {
                "type": "string",
                "description": "Optional relative path to list files from. Defaults to current directory if not provided."
            }
        },
        "required": []
    },
    function=list_files
)

Now Claude can combine tools — and it does this automatically:

You: Tell me about all the Python files in here. Be brief!
tool: list_files({})
tool: read_file({"path": "agent.py"})
Claude: Here's a quick overview:

**agent.py**: Implements an AI agent that can interact with the local 
filesystem. It uses the Anthropic SDK to communicate with Claude, 
provides tools for reading files and listing directories, and manages 
the conversation loop with tool execution.

This is a simple terminal-based chatbot with file system access.

Il a d’abord énuméré les fichiers pour trouver les fichiers Python, puis lu chacun d’eux. Tout comme vous – d’abord, puis les fichiers qui vous intéressent.

Étape 5 : L’outil edit_file — Là où ça devient passionnant

Voici un outil qui transforme notre agent de lecteur en éditeur. La mise en œuvre peut vous surprendre par sa simplicité :

def edit_file(input_data):
    """Edit a file by replacing old_str with new_str, or create a new file."""
    path = input_data["path"]
    old_str = input_data.get("old_str", "")
    new_str = input_data.get("new_str", "")
    
    if old_str == new_str:
        return "Error: old_str and new_str must be different"
    
    # If file doesn't exist and old_str is empty, create new file
    if not os.path.exists(path) and old_str == "":
        # Create directories if needed
        dir_name = os.path.dirname(path)
        if dir_name:
            os.makedirs(dir_name, exist_ok=True)
        
        with open(path, "w") as f:
            f.write(new_str)
        return f"Successfully created file {path}"
    
    # Read existing file
    try:
        with open(path, "r") as f:
            content = f.read()
    except FileNotFoundError:
        return f"Error: File '{path}' not found"
    
    # Replace old_str with new_str
    if old_str not in content:
        return "Error: old_str not found in file"
    
    new_content = content.replace(old_str, new_str, 1)  # Replace first occurrence only
    
    with open(path, "w") as f:
        f.write(new_content)
    
    return "OK"

agent.register_tool(
    name="edit_file",
    description="""Make edits to a text file.

Replaces 'old_str' with 'new_str' in the given file. 'old_str' and 'new_str' MUST be different from each other.

If the file specified with path doesn't exist, it will be created.""",
    input_schema={
        "type": "object",
        "properties": {
            "path": {
                "type": "string",
                "description": "The path to the file"
            },
            "old_str": {
                "type": "string",
                "description": "Text to search for - must match exactly and must only have one match exactly"
            },
            "new_str": {
                "type": "string",
                "description": "Text to replace old_str with"
            }
        },
        "required": ["path", "new_str"]
    },
    function=edit_file
)

Oui remplacement de chaînepour éditer des fichiers. C’est tout. Les LLM modernes comme Claude sont extrêmement efficaces pour générer des remplacements de chaînes exacts. Ils lisent le fichier, déterminent exactement ce qui doit être modifié et envoient les anciennes et les nouvelles lignes.

Voyons-le maintenant en action :

You: Create a fizzbuzz.py that prints FizzBuzz from 1 to 100
tool: edit_file({"path": "fizzbuzz.py", "old_str": "", "new_str": "def fizzbuzz(n):\n    for i in range(1, n + 1):\n        output = ''\n        if i % 3 == 0:\n            output += 'Fizz'\n        if i % 5 == 0:\n            output += 'Buzz'\n        print(output or i)\n\nif __name__ == '__main__':\n    print('Running FizzBuzz:')\n    fizzbuzz(100)"})
Claude: I've created fizzbuzz.py! You can run it with:
  python fizzbuzz.py

Vérifions que cela fonctionne :

$ python fizzbuzz.py
Running FizzBuzz:
1
2
Fizz
4
Buzz
Fizz
...
14
FizzBuzz

Maintenant demandons éditerdéposer:

You: Edit fizzbuzz.py to only print until 15
tool: read_file({"path": "fizzbuzz.py"})
tool: edit_file({"path": "fizzbuzz.py", "old_str": "fizzbuzz(100)", "new_str": "fizzbuzz(15)"})
Claude: Done! I've updated fizzbuzz.py to only print until 15.

Notez le workflow : Claude en premier litfichier pour comprendre son contenu, puis effectue un modification exacteen remplaçant uniquement la pièce qui doit être changée. Il n’a pas réécrit l’intégralité du fichier – il a remplacé chirurgicalement fizzbuzz(100) par fizzbuzz(15).

Mettre tout cela ensemble

Voici le fichier agent.py complet — moins de 200 lignes de logique réelle :

import os
import json
from anthropic import Anthropic

client = Anthropic()

# ---- Tool Implementations ----

def read_file(input_data):
    """Read the contents of a file."""
    path = input_data["path"]
    try:
        with open(path, "r") as f:
            return f.read()
    except FileNotFoundError:
        return f"Error: File '{path}' not found"
    except Exception as e:
        return f"Error reading file: {str(e)}"

def list_files(input_data):
    """List files and directories at a given path."""
    dir_path = input_data.get("path", ".")
    try:
        entries = []
        for item in os.listdir(dir_path):
            full_path = os.path.join(dir_path, item)
            if os.path.isdir(full_path):
                entries.append(f"{item}/")
            else:
                entries.append(item)
        return json.dumps(sorted(entries))
    except Exception as e:
        return f"Error listing files: {str(e)}"

def edit_file(input_data):
    """Edit a file by replacing old_str with new_str, or create a new file."""
    path = input_data["path"]
    old_str = input_data.get("old_str", "")
    new_str = input_data.get("new_str", "")
    
    if old_str == new_str:
        return "Error: old_str and new_str must be different"
    
    if not os.path.exists(path) and old_str == "":
        dir_name = os.path.dirname(path)
        if dir_name:
            os.makedirs(dir_name, exist_ok=True)
        with open(path, "w") as f:
            f.write(new_str)
        return f"Successfully created file {path}"
    
    try:
        with open(path, "r") as f:
            content = f.read()
    except FileNotFoundError:
        return f"Error: File '{path}' not found"
    
    if old_str and old_str not in content:
        return "Error: old_str not found in file"
    
    new_content = content.replace(old_str, new_str, 1)
    with open(path, "w") as f:
        f.write(new_content)
    return "OK"

# ---- Tool Definitions ----

TOOLS = [
    {
        "name": "read_file",
        "description": "Read the contents of a given relative file path. Use this when you want to see what's inside a file. Do not use this with directory names.",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "The relative path of a file in the working directory."
                }
            },
            "required": ["path"]
        }
    },
    {
        "name": "list_files",
        "description": "List files and directories at a given path. If no path is provided, lists files in the current directory.",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "Optional relative path to list files from. Defaults to current directory."
                }
            },
            "required": []
        }
    },
    {
        "name": "edit_file",
        "description": "Make edits to a text file. Replaces 'old_str' with 'new_str' in the given file. If the file doesn't exist and old_str is empty, creates a new file with new_str as content.",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "The path to the file"
                },
                "old_str": {
                    "type": "string",
                    "description": "Text to search for - must match exactly"
                },
                "new_str": {
                    "type": "string",
                    "description": "Text to replace old_str with"
                }
            },
            "required": ["path", "new_str"]
        }
    }
]

TOOL_FUNCTIONS = {
    "read_file": read_file,
    "list_files": list_files,
    "edit_file": edit_file,
}

# ---- Agent Loop ----

def run_agent():
    """Main agent loop with tool use."""
    conversation = []
    
    print("🤖 Code-Editing Agent (use 'ctrl-c' to quit)")
    print("I can read, list, and edit files in this directory.\n")
    
    while True:
        user_input = input("\033[94mYou\033[0m: ")
        conversation.append({"role": "user", "content": user_input})
        
        # Inner loop: keep running until no more tool calls
        while True:
            response = client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=4096,
                messages=conversation,
                tools=TOOLS
            )
            
            # Add response to conversation
            conversation.append({
                "role": "assistant",
                "content": response.content
            })
            
            # Process response blocks
            tool_results = []
            for block in response.content:
                if block.type == "text":
                    print(f"\033[93mClaude\033[0m: {block.text}")
                elif block.type == "tool_use":
                    print(f"\033[92mtool\033[0m: {block.name}({json.dumps(block.input)})")
                    
                    func = TOOL_FUNCTIONS.get(block.name)
                    if func:
                        result = func(block.input)
                    else:
                        result = f"Error: Unknown tool '{block.name}'"
                    
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": str(result)
                    })
            
            # If no tool calls, break inner loop
            if not tool_results:
                break
            
            # Send tool results back and continue
            conversation.append({"role": "user", "content": tool_results})

if __name__ == "__main__":
    run_agent()

Quel est le rapport avec les agents de production ?

Vous pourriez vous demander, si créer un agent est si simple, qu’est-ce qui rend les agents de production comme Amp, Cursor ou GitHub Copilot si impressionnants ?

La boucle principale est exactement ce que nous avons construit. La différence réside dans la conception autour de cette boucle :

Ce que nous avons construit contre l’agent de production

Comme expliqué dans le manuel de l’agent OpenAI, les agents de production utilisent également des modèles d’orchestration tels que :

• Un seul agent avec de nombreux outils– Commencez ici, développez progressivement
• Modèle de gestionnaire— Un agent central coordonne les sous-agents spécialisés
• Transfert décentralisé— Les agents se transfèrent des tâches de spécialisation

Points clés de leur leadership : « Maximiser d’abord l’agent unique » avant de passer à une architecture multi-agents.

Les principaux enseignements de la création de cet agent

Voici les points importants à retenir :

1. La description de l’outil compte plus que vous ne le pensez

La description que vous écrivez pour chaque outil est essentiellement une info-bulle. Claude en profite pour décider quand et comment utiliser l’outil. Rédigez des descriptions claires et spécifiques, y compris ce que fait l’outil, quelles entrées il attend et quand NE PAS l’utiliser.

2. Le modèle décide quand utiliser les outils

Nous n’avons jamais écrit de logique conditionnelle telle que “si l’utilisateur mentionne un fichier, appelez read_file”. LLM le découvre par lui-même en se basant sur les descriptions des outils et l’intention de l’utilisateur. C’est l’aspect le plus puissant de l’utilisation de l’outil.

3. Gardez les résultats des outils simples

Renvoie des chaînes simples ou JSON. Plus le format est simple, plus il est facile de traiter le modèle. Nous renvoyons “OK” en cas de modifications réussies et un message d’erreur en cas d’échec, c’est tout ce dont Claude a besoin.

4. La boucle est tout

Une boucle interne while True qui continue de traiter les appels de l’outil jusqu’à ce qu’il n’en reste plus, c’est toute la différence entre un chatbot et un agent. Le chatbot effectue un appel d’inférence par tour. L’agent fait tout ce qu’il doit.

5. Le remplacement des chaînes fonctionne étonnamment bien

Vous pourriez vous attendre à ce que l’édition de fichiers nécessite une analyse AST, un économiseur d’arborescence ou un algorithme de comparaison complexe. Mais Claude est formé pour générer des remplacements exacts de chaînes, et cela fonctionne extrêmement bien. C’est ainsi que de nombreux éditeurs de code en production mettent en œuvre leurs outils d’édition.

Quelle est la prochaine étape ? Extension de votre agent

Maintenant que vous disposez d’un agent fonctionnel, voici quelques idées pour l’étendre :

• Ajouter un l’outil run_command– Autoriser Claude à exécuter des commandes shell et voir le résultat
• Ajouter un outil search_files– Parcourez les fichiers pour trouver le code correspondant
• Ajouter une invite système— Parlez à Claude du projet, des normes de codage et des lignes directrices
• Ajouter un flux— Utilisez l’API de streaming d’Anthropic pour une sortie en temps réel
• Ajouter des barrières de sécurité— Confirmer avant les opérations destructives (supprimer, écraser)
• Ajouter de la mémoire– Enregistrer les résumés de conversation entre les sessions

Chacun n’est qu’une autre définition d’outil + fonction. Le cycle des agents reste le même.

Réflexions finales

Créer un agent IA n’est pas compliqué. Il s’agit du LLM, cycle et outils. Les trois outils que nous avons créés, read_file, list_files et edit_file, suffisent pour créer un agent capable de naviguer de manière autonome dans votre base de code et d’apporter des modifications importantes.

Une véritable compréhension du peu de code requis. Moins de 200 lignes de logique Python et vous obtenez quelque chose qui ressemble vraiment à un assistant intelligent éditant votre code. Les modèles sont incroyablement puissants, ils n’ont désormais plus besoin que des bons outils et de la bonne boucle.

Si vous créez des applications d’IA et n’avez pas encore exploré l’utilisation des outils, je vous recommande fortement de commencer avec cet agent simple. Une fois que vous aurez lu le fichier, réfléchissez-y et apporté les modifications précises, vous comprendrez pourquoi tout le monde dans l’industrie parle d’agents.

L’empereur n’a pas de vêtements. Et c’est en fait la chose la plus intéressante – c’est toi peut le construire aussi.

Inspiré par Torsten Ball Comment créer un agent. Implémentation originale en Go adaptée à Python pour ce blog.

Tout le code de ce blog est disponible et prêt à copier-coller. Essayez de créer votre propre agent et voyez jusqu’où vous pouvez aller !

Comment créer un agent IA à partir de zéro est plus facile que vous ne le pensez a été initialement publié sur Stackademic sur Medium, où les gens poursuivent la conversation en soulignant et en répondant à cette histoire.

Berita Terkini

Berita Terbaru

Daftar Terbaru

News

Berita Terbaru

Flash News

RuangJP

Pemilu

Berita Terkini

Prediksi Bola

Technology

Otomotif

Berita Terbaru

Teknologi

Berita terkini

Berita Pemilu

Berita Teknologi

Hiburan

master Slote

Berita Terkini

Pendidikan

Resep

Cek Ongkir Cargo

Togel Deposit Pulsa

Daftar Judi Slot Online Terpercaya

Slot yang lagi gacor