Agents interactifs de type REPL
Boucles d’entrée, historique et conversation à plusieurs tours dans les agents de terminal.
Agents interactifs de type REPL est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.
Qu’est-ce qu’un agent de type REPL
Un REPL (boucle de lecture-évaluation-affichage) est une session interactive dans un terminal où vous saisissez une entrée, obtenez une sortie, puis continuez. Les agents conversationnels dans le terminal fonctionnent exactement ainsi : l’utilisateur saisit un message, l’agent répond, puis la conversation continue jusqu’à ce que l’utilisateur quitte le programme.
La boucle REPL de base
Le REPL le plus simple est une boucle while True qui lit l’entrée de l’utilisateur avec input(), la traite et affiche le résultat. La boucle s’exécute indéfiniment jusqu’à ce que l’utilisateur signale qu’il veut quitter le programme.
def run_agent_repl(inputs):
print('Agent started. Type /exit to quit.')
conversation_history = []
for user_input in inputs:
user_input = user_input.strip()
if not user_input:
continue
if user_input == '/exit':
print('Goodbye!')
break
conversation_history.append({'role': 'user', 'content': user_input})
agent_reply = f'[Agent reply to: {user_input}]'
conversation_history.append({'role': 'assistant', 'content': agent_reply})
print(f'Agent: {agent_reply}')
run_agent_repl(['Hello agent', 'What can you do?', '/exit'])Gérer KeyboardInterrupt avec élégance
Lorsqu’un utilisateur appuie sur Ctrl+C, Python déclenche une exception KeyboardInterrupt. Interceptez-la au niveau supérieur pour afficher un message d’au revoir convivial au lieu d’une trace de la pile.
def run_agent_repl():
print('Agent ready. Press Ctrl+C to exit.')
conversation_history = []
try:
while True:
user_input = input('You: ').strip()
if not user_input:
continue
conversation_history.append({'role': 'user', 'content': user_input})
reply = '[mocked agent response]'
conversation_history.append({'role': 'assistant', 'content': reply})
print(f'Agent: {reply}')
except KeyboardInterrupt:
print('\nSession ended. Goodbye!')
except EOFError:
# Triggered when stdin is closed (piped input ends)
print('\nEnd of input. Exiting.')
if __name__ == '__main__':
import builtins
_demo_inputs = iter(['What agents can you build?', EOFError])
def _fake_input(prompt=''):
val = next(_demo_inputs)
if val is EOFError:
raise EOFError
print(prompt + val)
return val
builtins.input = _fake_input
run_agent_repl()
Conserver l’historique des conversations à plusieurs tours
Pour donner à l’agent une mémoire de la conversation, conservez une liste de messages et transmettez l’historique complet au LLM à chaque tour. Commencez par un message système qui définit la personnalité de l’agent.
import openai
client = openai.OpenAI(api_key='YOUR_API_KEY')
def run_chat_repl():
history = [
{'role': 'system', 'content': 'You are a helpful AI assistant.'}
]
print('Chat started. Type /exit to quit.')
try:
while True:
user_input = input('You: ').strip()
if not user_input or user_input == '/exit':
break
history.append({'role': 'user', 'content': user_input})
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=history
)
reply = response.choices[0].message.content
history.append({'role': 'assistant', 'content': reply})
print(f'Agent: {reply}')
except KeyboardInterrupt:
print('\nGoodbye!')readline : historique et modification de l’entrée
Le module readline (Unix/Mac) permet de parcourir les entrées précédentes avec les touches fléchées, comme dans un véritable interpréteur de commandes. Les utilisateurs peuvent appuyer sur la flèche vers le haut pour rappeler des messages précédents.
try:
import readline # available on Unix/Mac, not Windows
# Enable persistent history between sessions
import os
HISTORY_FILE = os.path.expanduser('~/.agent_history')
try:
readline.read_history_file(HISTORY_FILE)
except FileNotFoundError:
pass
import atexit
atexit.register(readline.write_history_file, HISTORY_FILE)
readline.set_history_length(500)
print('History enabled (use up/down arrows)')
except ImportError:
pass # readline not available on Windows
# After this, input() automatically has history supportCommandes slash intégrées
Ajoutez à votre agent REPL des commandes slash intégrées pour les opérations courantes : /help, /exit, /clear pour réinitialiser la conversation et /history pour afficher les messages précédents.
def handle_command(cmd: str, history: list) -> bool:
'Returns True if the command was handled, False if it is a regular message'
if cmd == '/exit' or cmd == '/quit':
print('Goodbye!')
raise SystemExit(0)
elif cmd == '/help':
print('Commands: /exit, /clear, /history, /help')
return True
elif cmd == '/clear':
# Keep only the system message
system = history[0] if history and history[0]['role'] == 'system' else None
history.clear()
if system:
history.append(system)
print('[Conversation cleared]')
return True
elif cmd == '/history':
for i, msg in enumerate(history):
if msg['role'] != 'system':
print(f' [{msg["role"]}] {msg["content"][:80]}')
return True
return False # not a command, treat as regular message
if __name__ == '__main__':
demo_history = [
{'role': 'system', 'content': 'You are a helpful agent.'},
{'role': 'user', 'content': 'Hi there'},
{'role': 'assistant', 'content': 'Hello! How can I help?'},
]
handle_command('/help', demo_history)
handle_command('/history', demo_history)
Limiter la longueur de l’historique des conversations
Transmettre l’intégralité de l’historique de la conversation au LLM à chaque tour augmente linéairement le nombre de jetons. Réduisez l’historique aux N derniers messages, en conservant le message système, afin de maîtriser les coûts.
def trim_history(history: list, max_turns: int = 10) -> list:
system_messages = [m for m in history if m['role'] == 'system']
non_system = [m for m in history if m['role'] != 'system']
# Keep the last max_turns messages (each turn = 1 user + 1 assistant)
max_messages = max_turns * 2
trimmed = non_system[-max_messages:]
return system_messages + trimmed
# Usage in the REPL loop:
# history.append({'role': 'user', 'content': user_input})
# trimmed = trim_history(history, max_turns=10)
# response = client.chat.completions.create(model='gpt-4o-mini', messages=trimmed)
print('Trimming history prevents token count from growing unboundedly')Afficher une bannière de bienvenue
Une bannière de bienvenue donne une apparence soignée à votre REPL. Affichez-la une seule fois au démarrage, avec le nom de l’agent, sa version et les commandes disponibles. Utilisez un dessin ASCII simple ou la bibliothèque rich pour la couleur.
def print_banner():
banner = '''
====================================
AI Research Agent v1.0
====================================
Type your question to begin.
Commands: /help /clear /exit
====================================
'''
print(banner)
# Or with rich colors:
# from rich.console import Console
# from rich.panel import Panel
# console = Console()
# console.print(Panel('[bold cyan]AI Research Agent[/] v1.0', subtitle='Type /help for commands'))
print_banner()Afficher des indicateurs de réflexion
Les appels au LLM peuvent prendre plusieurs secondes. Affichez un message « réflexion en cours… » pendant l’attente afin que les utilisateurs sachent que l’agent traite leur demande. Effacez-le lorsque la réponse arrive.
import sys
import threading
import time
def thinking_spinner(stop_event: threading.Event):
frames = ['|', '/', '-', '\\']
i = 0
while not stop_event.is_set():
sys.stdout.write(f'\rAgent is thinking... {frames[i % 4]}')
sys.stdout.flush()
time.sleep(0.1)
i += 1
sys.stdout.write('\r' + ' ' * 30 + '\r') # clear the line
sys.stdout.flush()
def call_agent_with_spinner(query: str) -> str:
stop = threading.Event()
spinner = threading.Thread(target=thinking_spinner, args=(stop,))
spinner.start()
# result = agent.run(query) # the actual slow call
time.sleep(1) # simulating work
result = 'The answer is 42.'
stop.set()
spinner.join()
return result
if __name__ == '__main__':
answer = call_agent_with_spinner('What is 6 * 7?')
print(f'\nFinal answer: {answer}')
Enregistrer la session dans un fichier
Permettez aux utilisateurs d’enregistrer la conversation dans un fichier à la fin d’une session. Cela est utile pour les sessions de recherche dont vous souhaitez conserver une trace des résultats trouvés par l’agent.
import json
import datetime
import os
def save_session(history: list, directory: str = 'sessions'):
os.makedirs(directory, exist_ok=True)
timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
filename = os.path.join(directory, f'session_{timestamp}.json')
with open(filename, 'w') as f:
json.dump({
'saved_at': timestamp,
'messages': history
}, f, indent=2)
print(f'Session saved to {filename}')
# Usage in REPL on /save command:
# save_session(conversation_history)
if __name__ == '__main__':
import tempfile
demo_dir = tempfile.mkdtemp()
demo_history = [
{'role': 'user', 'content': 'Hello'},
{'role': 'assistant', 'content': 'Hi! How can I help?'},
]
save_session(demo_history, directory=demo_dir)
Modèle complet d’agent REPL
En réunissant tous ces éléments, vous obtenez un modèle REPL prêt pour la production, avec gestion de l’historique, commandes slash, gestion des interruptions au clavier et enregistrement des sessions.
def run_repl(agent):
history = [{'role': 'system', 'content': 'You are a helpful AI assistant.'}]
print('Agent ready. Type /help for commands.')
try:
while True:
user_input = input('You: ').strip()
if not user_input:
continue
if user_input.startswith('/'):
handle_command(user_input, history)
continue
history.append({'role': 'user', 'content': user_input})
trimmed = trim_history(history, max_turns=10)
reply = agent.run(trimmed)
history.append({'role': 'assistant', 'content': reply})
print(f'Agent: {reply}')
except KeyboardInterrupt:
print('\nSession ended.')
save_session(history)Vérification des connaissances : agents de type REPL
Vérifiez votre compréhension des agents REPL interactifs.
Récapitulatif : agents REPL interactifs
Vous savez maintenant créer un agent interactif complet pour le terminal :
- Utiliser
while True: input()comme boucle de lecture principale - Intercepter
KeyboardInterruptpour quitter proprement avec Ctrl+C - Conserver une liste
conversation_historypour la mémoire à plusieurs tours - Utiliser
readlinepour l’historique des entrées avec les touches fléchées - Implémenter les commandes slash
/help,/clearet/exit - Réduire l’historique pour éviter une croissance illimitée du nombre de jetons
- Afficher un indicateur tournant ou de progression pendant les appels au LLM
Questions Fréquemment Posées
La leçon « Agents interactifs de type REPL » est-elle gratuite ?
Oui — le texte complet de « Agents interactifs de type REPL » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Agents interactifs de type REPL » ?
Boucles d’entrée, historique et conversation à plusieurs tours dans les agents de terminal. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Agents ?
Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Agents interactifs de type REPL » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?
Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Créer des interfaces d’agents en ligne de commande
- Agents interactifs de type REPL
- Analyser les arguments et rédiger l’aide
- Diffuser la sortie des agents CLI