0Pricing
AI Agents · Leçon

Créer des interfaces d’agents en ligne de commande

argparse, click et Typer pour gérer les arguments de l’agent dans le CLI.

Créer des interfaces d’agents en ligne de commande est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 1 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.

Pourquoi créer une CLI pour votre agent ?

Une interface en ligne de commande (CLI) rend votre agent accessible depuis un terminal, permet de l'intégrer à des chaînes de traitement et facilite son test sans interface web. De nombreux agents de production sont déployés comme outils CLI.

Python propose trois excellentes bibliothèques pour créer des CLI : argparse (bibliothèque standard), Typer et Click.

argparse : l'option de la bibliothèque standard

argparse est intégré à Python — aucune installation n'est nécessaire. Utilisez ArgumentParser() pour définir votre interface, add_argument() pour déclarer les paramètres et parse_args() pour les traiter.

import argparse

def main(argv=None):
    parser = argparse.ArgumentParser(
        description='AI Agent CLI — ask questions and get answers'
    )
    parser.add_argument('--query', type=str, required=True, help='The question to ask the agent')
    parser.add_argument('--model', type=str, default='gpt-4o-mini', help='OpenAI model to use (default: gpt-4o-mini)')
    args = parser.parse_args(argv)

    print(f'Querying agent with: {args.query}')
    print(f'Using model: {args.model}')

if __name__ == '__main__':
    main(['--query', 'What is the weather today?'])

Exécuter une CLI argparse et afficher l'aide générée automatiquement

argparse génère automatiquement un message --help à partir de vos définitions d'arguments. Exécutez python agent_cli.py --help pour l'afficher. Les arguments requis qui manquent produisent automatiquement des messages d'erreur utiles.

# How users invoke the CLI:
# python agent_cli.py --query 'What is the weather in Paris?'
# python agent_cli.py --query 'Summarize this' --model gpt-4o
# python agent_cli.py --help

# Auto-generated help output:
# usage: agent_cli.py [-h] --query QUERY [--model MODEL]
#
# AI Agent CLI -- ask questions and get answers
#
# options:
#   -h, --help     show this help message and exit
#   --query QUERY  The question to ask the agent
#   --model MODEL  OpenAI model to use (default: gpt-4o-mini)

print('argparse generates help text automatically from your definitions')

Typer : interface CLI moderne avec annotations de type

Typer crée des interfaces CLI à partir des annotations de type Python, avec moins de code répétitif qu’avec argparse. Installez-le avec pip install typer. Les paramètres des fonctions deviennent automatiquement des arguments de CLI.

# pip install typer
import typer

app = typer.Typer(help='AI Agent CLI')

@app.command()
def ask(
    query: str = typer.Option(..., '--query', '-q', help='Question for the agent'),
    model: str = typer.Option('gpt-4o-mini', '--model', '-m', help='Model to use'),
    verbose: bool = typer.Option(False, '--verbose', '-v', help='Show reasoning steps')
):
    typer.echo(f'Query: {query}')
    typer.echo(f'Model: {model}')
    if verbose:
        typer.echo('Verbose mode enabled')
    # result = run_agent(query, model=model, verbose=verbose)

if __name__ == '__main__':
    app()

Click : infrastructure CLI fondée sur des décorateurs

Click utilise des décorateurs pour définir les commandes et les options d’une CLI. Installez-le avec pip install click. Il propose de nombreuses fonctionnalités, comme les groupes de commandes, les invites et les barres de progression.

# pip install click
import click

@click.command()
@click.option('--query', '-q', required=True, help='Question for the agent')
@click.option('--model', '-m', default='gpt-4o-mini', help='LLM model to use')
@click.option('--output', '-o', type=click.Path(), help='Save output to file')
def ask(query: str, model: str, output: str):
    click.echo(f'Sending: {query}')
    # result = run_agent(query, model=model)
    # click.echo(result['answer'])

    if output:
        with open(output, 'w') as f:
            f.write('result["answer"]')
        click.echo(f'Saved to {output}')

if __name__ == '__main__':
    ask()

Ajouter des sous-commandes

À mesure que votre agent se développe, organisez ses fonctionnalités en sous-commandes comme agent ask, agent search et agent history. Click et Typer prennent tous deux en charge nativement les groupes de sous-commandes.

import typer

app = typer.Typer(help='AI Research Agent')

@app.command()
def ask(query: str = typer.Argument(..., help='Question to ask')):
    'Ask the agent a question'
    typer.echo(f'Asking: {query}')

@app.command()
def search(topic: str = typer.Argument(..., help='Topic to research')):
    'Search and summarize a topic'
    typer.echo(f'Researching: {topic}')

@app.command()
def history(limit: int = typer.Option(10, help='Number of past queries to show')):
    'Show recent query history'
    typer.echo(f'Showing last {limit} queries')

if __name__ == '__main__':
    app()

# Usage: python agent.py ask 'What is AI?'
#        python agent.py search 'Python async'
#        python agent.py history --limit 5

Lire l’entrée standard pour une entrée redirigée

Un agent CLI qui lit depuis l’entrée standard peut être utilisé dans des chaînes de traitement Unix. Utilisez sys.stdin ou le type d’argument stdin de Click pour accepter du contenu redirigé.

import sys
import click

@click.command()
@click.argument('input', default='-', type=click.File('r'))
@click.option('--task', default='summarize', help='Task: summarize, translate, or analyze')
def process(input, task: str):
    text = input.read().strip()
    if not text:
        click.echo('Error: no input provided', err=True)
        raise SystemExit(1)

    click.echo(f'Task: {task}')
    click.echo(f'Input length: {len(text)} chars')
    # result = agent.run(task=task, content=text)
    # click.echo(result)

# Usage:
# echo 'Hello world' | python agent_cli.py --task translate
# cat article.txt | python agent_cli.py --task summarize
if __name__ == '__main__':
    process()

Indicateurs de progression pour les tâches longues

Les tâches d’un agent peuvent prendre plusieurs secondes. Affichez un indicateur tournant ou un message de progression afin que les utilisateurs sachent que l’agent travaille. Typer intègre la prise en charge de la progression grâce à la bibliothèque rich.

import typer
from time import sleep

app = typer.Typer()

@app.command()
def research(topic: str = typer.Argument(...)):
    typer.echo(f'Researching: {topic}')

    with typer.progressbar(range(5), label='Gathering sources') as progress:
        for i in progress:
            sleep(0.5)  # simulate work

    typer.echo('Done!')
    typer.echo('Result: [mocked research result]')

# Or with a spinner from rich:
# from rich.console import Console
# console = Console()
# with console.status('Thinking...'):
#     result = agent.run(topic)
# console.print(result)

if __name__ == '__main__':
    app()

Formatage de la sortie : JSON ou texte brut

Permettez aux utilisateurs de choisir entre des formats de sortie lisibles par les humains et lisibles par les machines. Une option --json est utile pour acheminer la sortie de l’agent vers d’autres outils.

import json
import typer

app = typer.Typer()

@app.command()
def ask(
    query: str = typer.Argument(...),
    as_json: bool = typer.Option(False, '--json', help='Output as JSON')
):
    result = {
        'query': query,
        'answer': 'Paris is the capital of France.',
        'confidence': 0.98,
        'sources': ['https://wikipedia.org/France']
    }

    if as_json:
        typer.echo(json.dumps(result, indent=2))
    else:
        typer.echo(f'Answer: {result["answer"]}')
        typer.echo(f'Sources: {', '.join(result["sources"])}')

if __name__ == '__main__':
    app()

Gestion des erreurs dans les agents CLI

Terminez avec un code différent de zéro en cas d’erreur afin que les scripts appelants puissent détecter les échecs. Utilisez typer.echo(..., err=True) ou click.echo(..., err=True) pour écrire les messages d’erreur sur stderr.

import sys
import typer

app = typer.Typer()

@app.command()
def ask(query: str = typer.Argument(...)):
    try:
        # result = agent.run(query)
        result = {'status': 'ok', 'answer': 'Result here'}

        if result['status'] != 'ok':
            typer.echo(f'Agent error: {result.get("error")}', err=True)
            raise typer.Exit(code=1)

        typer.echo(result['answer'])

    except Exception as e:
        typer.echo(f'Unexpected error: {e}', err=True)
        raise typer.Exit(code=2)

# Exit codes: 0 = success, 1 = agent error, 2 = unexpected error
# These allow shell scripts to handle failures:
# python agent.py 'query' || echo 'Agent failed'
if __name__ == '__main__':
    app()

Transformer votre agent en outil CLI installable

Utilisez un point d’entrée dans pyproject.toml pour rendre votre agent disponible comme commande système. Après pip install -e ., les utilisateurs peuvent exécuter directement myagent ask 'question' depuis n’importe quel répertoire.

# pyproject.toml
# [project]
# name = 'myagent'
# version = '0.1.0'
# dependencies = ['typer', 'openai', 'httpx']
#
# [project.scripts]
# myagent = 'myagent.cli:app'

# After pip install -e .:
# myagent ask 'What is AI?'
# myagent search 'Python tutorials'
# myagent --help

# This is how production CLI agents like 'gh', 'poetry', and 'ruff' work
print('Entry points turn your Python module into a system CLI command')

Vérification des connaissances : interfaces CLI pour agents

Vérifiez votre compréhension de la création d’interfaces CLI pour les agents.

Récapitulatif : créer des interfaces CLI pour agents

Vous savez maintenant créer des interfaces CLI professionnelles pour vos agents :

  • Utiliser argparse pour des CLI sans dépendance (bibliothèque standard)
  • Utiliser typer pour des CLI claires fondées sur les annotations de type
  • Utiliser click pour des CLI riches en fonctionnalités et fondées sur des décorateurs
  • Organiser les agents volumineux avec des sous-commandes
  • Prendre en charge l’entrée standard pour l’intégration aux chaînes de traitement
  • Utiliser des options --json pour une sortie lisible par les machines
  • Terminer avec des codes différents de zéro en cas d’erreur pour assurer la compatibilité avec les scripts d’interpréteur de commandes

Questions Fréquemment Posées

La leçon « Créer des interfaces d’agents en ligne de commande » est-elle gratuite ?

Oui — le texte complet de « Créer des interfaces d’agents en ligne de commande » 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 « Créer des interfaces d’agents en ligne de commande » ?

argparse, click et Typer pour gérer les arguments de l’agent dans le CLI. 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 1 sur 4.

Combien de temps prend la leçon « Créer des interfaces d’agents en ligne de commande » ?

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

  1. Créer des interfaces d’agents en ligne de commande
  2. Agents interactifs de type REPL
  3. Analyser les arguments et rédiger l’aide
  4. Diffuser la sortie des agents CLI
← Retour à AI Agents