0Pricing
AI Agents · Lektion

Interaktive Agenten im REPL-Stil

Eingabeschleifen, Verlauf und mehrstufige Konversationen in Terminal-Agenten.

Interaktive Agenten im REPL-Stil ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Was ist ein Agent im REPL-Stil?

Ein REPL (Read-Eval-Print Loop) ist eine interaktive Terminalsitzung, in der Sie Eingaben machen, Ausgaben erhalten und fortfahren. Chat-Agenten im Terminal funktionieren genau so: Der Benutzer gibt eine Nachricht ein, der Agent antwortet und die Unterhaltung wird fortgesetzt, bis der Benutzer das Programm beendet.

Die grundlegende REPL-Schleife

Die einfachste REPL ist eine while True-Schleife, die mit input() Benutzereingaben liest, verarbeitet und das Ergebnis ausgibt. Die Schleife läuft unbegrenzt, bis der Benutzer das Beenden signalisiert.

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'])

KeyboardInterrupt sauber behandeln

Wenn ein Benutzer Ctrl+C drückt, löst Python einen KeyboardInterrupt aus. Fangen Sie ihn auf oberster Ebene ab, um statt eines Stacktraces eine freundliche Abschiedsmeldung auszugeben.

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()

Mehrturnige Gesprächshistorie verwalten

Damit der Agent sich an die Unterhaltung erinnern kann, verwalten Sie eine Liste von Nachrichten und übergeben Sie dem LLM bei jedem Turn die vollständige Historie. Beginnen Sie mit einer Systemnachricht, die die Persona des Agenten festlegt.

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: Eingabeverlauf und Bearbeitung

Das Modul readline (Unix/Mac) ermöglicht die Navigation mit den Pfeiltasten durch vorherige Eingaben, genau wie in einer echten Shell. Benutzer können die Pfeiltaste nach oben drücken, um frühere Nachrichten erneut aufzurufen.

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 support

Integrierte Slash-Befehle

Geben Sie Ihrem REPL-Agenten integrierte Slash-Befehle für häufige Vorgänge: /help, /exit, /clear zum Zurücksetzen der Unterhaltung und /history zum Anzeigen früherer Nachrichten.

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)

Länge der Gesprächshistorie begrenzen

Wenn Sie dem LLM bei jedem Turn die gesamte Gesprächshistorie übergeben, wächst die Tokenanzahl linear. Kürzen Sie die Historie auf die letzten N Nachrichten (wobei die Systemnachricht erhalten bleibt), um die Kosten zu kontrollieren.

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')

Ein Willkommensbanner anzeigen

Ein Willkommensbanner verleiht Ihrer REPL einen professionellen Eindruck. Geben Sie es beim Start einmalig mit dem Namen und der Version des Agenten sowie den verfügbaren Befehlen aus. Verwenden Sie einfache ASCII-Art oder die Bibliothek rich für Farben.

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()

Tippindikatoren anzeigen

LLM-Aufrufe können mehrere Sekunden dauern. Zeigen Sie während des Wartens eine Meldung wie „thinking...“ an, damit Benutzer wissen, dass der Agent die Anfrage verarbeitet. Entfernen Sie sie, sobald die Antwort eintrifft.

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}')

Sitzung in einer Datei speichern

Ermöglichen Sie Benutzern, die Unterhaltung am Ende einer Sitzung in einer Datei zu speichern. Das ist für Recherchesitzungen nützlich, bei denen Sie festhalten möchten, was der Agent herausgefunden hat.

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)

Vollständige REPL-Agent-Vorlage

Alles zusammengeführt: eine produktionsreife REPL-Vorlage mit Verwaltung der Historie, Slash-Befehlen, Behandlung von Tastaturunterbrechungen und dem Speichern von Sitzungen.

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)

Wissensüberprüfung: Agenten im REPL-Stil

Testen Sie Ihr Verständnis interaktiver REPL-Agenten.

Zusammenfassung: Interaktive Agenten im REPL-Stil

Sie können jetzt einen interaktiven Agenten mit umfangreichen Funktionen für das Terminal erstellen:

  • Verwenden Sie while True: input() als zentrale Leseschleife
  • Fangen Sie KeyboardInterrupt für ein sauberes Beenden mit Ctrl+C ab
  • Verwalten Sie eine conversation_history-Liste für mehrturnige Erinnerungen
  • Verwenden Sie readline für den Eingabeverlauf über die Pfeiltasten
  • Implementieren Sie die Slash-Befehle /help, /clear und /exit
  • Kürzen Sie die Historie, um ein unbeschränktes Token-Wachstum zu verhindern
  • Zeigen Sie während LLM-Aufrufen einen Spinner oder eine Fortschrittsanzeige an

Häufig gestellte Fragen

Ist die Lektion „Interaktive Agenten im REPL-Stil“ kostenlos?

Ja — der vollständige Text von „Interaktive Agenten im REPL-Stil“ 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 „Interaktive Agenten im REPL-Stil“?

Eingabeschleifen, Verlauf und mehrstufige Konversationen in Terminal-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 2 von 4.

Wie lange dauert die Lektion „Interaktive Agenten im REPL-Stil“?

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

  1. Kommandozeilen-Oberflächen für Agenten erstellen
  2. Interaktive Agenten im REPL-Stil
  3. Argumente parsen und Hilfetexte erstellen
  4. Streaming-Ausgabe in CLI-Agenten
← Zurück zu AI Agents