Kommandozeilen-Oberflächen für Agenten erstellen
argparse, click und Typer für die Verarbeitung von CLI-Argumenten in Agenten.
Kommandozeilen-Oberflächen für Agenten erstellen ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Agents-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.
Warum eine CLI für Ihren Agenten erstellen?
Eine Kommandozeilenschnittstelle (CLI) macht Ihren Agenten über ein Terminal zugänglich, in Pipelines skriptfähig und ohne Weboberfläche leicht testbar. Viele Agenten im Produktiveinsatz werden als CLI-Tools bereitgestellt.
Python bietet drei hervorragende Bibliotheken zum Erstellen von CLIs: argparse (Standardbibliothek), Typer und Click.
argparse: Die Option aus der Standardbibliothek
argparse ist in Python integriert – eine Installation ist nicht erforderlich. Verwenden Sie ArgumentParser(), um Ihre Schnittstelle zu definieren, add_argument(), um Parameter zu deklarieren, und parse_args(), um sie zu verarbeiten.
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?'])argparse-CLI ausführen und automatisch generierte Hilfe anzeigen
argparse generiert automatisch eine --help-Nachricht aus Ihren Argumentdefinitionen. Führen Sie python agent_cli.py --help aus, um sie anzuzeigen. Für fehlende erforderliche Argumente werden automatisch hilfreiche Fehlermeldungen ausgegeben.
# 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: Moderne CLI mit Type Hints
Typer erstellt CLIs aus Python-Type-Hints – mit weniger Boilerplate als argparse. Installieren Sie es mit pip install typer. Funktionsparameter werden automatisch zu CLI-Argumenten.
# 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: Dekoratorbasiertes CLI-Framework
Click verwendet Dekoratoren, um CLI-Befehle und Optionen zu definieren. Installieren Sie es mit pip install click. Es bietet umfangreiche Funktionen wie Befehlsgruppen, Eingabeaufforderungen und Fortschrittsbalken.
# 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()Unterbefehle hinzufügen
Wenn Ihr Agent wächst, strukturieren Sie die Funktionalität in Unterbefehle wie agent ask, agent search und agent history. Sowohl Click als auch Typer unterstützen Befehlsgruppen für Unterbefehle standardmäßig.
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 5Aus stdin für weitergeleitete Eingaben lesen
Ein CLI-Agent, der aus stdin liest, kann in Unix-Pipelines verwendet werden. Verwenden Sie sys.stdin oder den Click-Argumenttyp stdin, um weitergeleitete Inhalte zu akzeptieren.
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()Fortschrittsanzeigen für lang dauernde Aufgaben
Agent-Aufgaben können mehrere Sekunden dauern. Zeigen Sie einen Spinner oder eine Fortschrittsmeldung an, damit Benutzer wissen, dass der Agent arbeitet. Typer bietet über die Bibliothek rich integrierte Unterstützung für Fortschrittsanzeigen.
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()Ausgabeformatierung: JSON oder Klartext
Ermöglichen Sie Benutzern, zwischen menschenlesbaren und maschinenlesbaren Ausgabeformaten zu wählen. Ein --json-Flag eignet sich, um die Agent-Ausgabe an andere Tools weiterzuleiten.
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()Fehlerbehandlung in CLI-Agenten
Beenden Sie das Programm bei Fehlern mit einem Exit-Code ungleich null, damit aufrufende Skripte Fehlschläge erkennen können. Verwenden Sie typer.echo(..., err=True) oder click.echo(..., err=True), um Fehlermeldungen nach stderr zu schreiben.
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()Ihren Agenten zu einem installierbaren CLI-Tool machen
Verwenden Sie einen Entry Point in pyproject.toml, damit Ihr Agent als Systembefehl verfügbar wird. Nach pip install -e . können Benutzer myagent ask 'question' direkt aus jedem Verzeichnis ausführen.
# 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')Wissensüberprüfung: CLI-Agent-Schnittstellen
Testen Sie Ihr Verständnis beim Erstellen von CLI-Schnittstellen für Agenten.
Zusammenfassung: CLI-Agent-Schnittstellen erstellen
Sie können jetzt professionelle CLI-Schnittstellen für Ihre Agenten erstellen:
- Verwenden Sie
argparsefür CLIs ohne zusätzliche Abhängigkeiten (Standardbibliothek) - Verwenden Sie
typerfür übersichtliche, durch Type Hints gesteuerte CLIs - Verwenden Sie
clickfür funktionsreiche, dekoratorbasierte CLIs - Strukturieren Sie große Agenten mit Unterbefehlen
- Unterstützen Sie stdin für die Integration in Pipelines
- Verwenden Sie
--json-Flags für maschinenlesbare Ausgaben - Beenden Sie das Programm bei Fehlern mit Exit-Codes ungleich null, damit es mit Shell-Skripten kompatibel bleibt
Häufig gestellte Fragen
Ist die Lektion „Kommandozeilen-Oberflächen für Agenten erstellen“ kostenlos?
Ja — der vollständige Text von „Kommandozeilen-Oberflächen für Agenten erstellen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Agents-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Kommandozeilen-Oberflächen für Agenten erstellen“?
argparse, click und Typer für die Verarbeitung von CLI-Argumenten in Agenten. Du übst AI Agents mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Agents zu starten?
Keine Vorkenntnisse erforderlich. AI Agents auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Kommandozeilen-Oberflächen für Agenten erstellen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Agents-Lektion Code schreiben und ausführen?
Ja. Jede AI Agents-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Kommandozeilen-Oberflächen für Agenten erstellen
- Interaktive Agenten im REPL-Stil
- Argumente parsen und Hilfetexte erstellen
- Streaming-Ausgabe in CLI-Agenten