Erstellen und Betreiben Sie Ihren eigenen KI-Agenten in der Cloud

Bauen und Betreiben Sie Ihren eigenen KI-Agenten in der Cloud

Die Ära der KI-Agenten ist angebrochen. Tools wie die auf den OpenAI News und dem Microsoft AI Blog diskutierten zeigen, dass autonome Agenten keine reinen Forschungsprojekte mehr sind – sie sind praktische Werkzeuge zur Automatisierung von Arbeitsabläufen, zur Datenanalyse und zur Interaktion mit APIs. Aber Sie brauchen kein riesiges Budget, um einen zu bauen. Mit Cloud-Computing und Open-Source-Frameworks können Sie Ihren eigenen KI-Agenten in wenigen Minuten bereitstellen.

Dieser Artikel führt Sie durch den Bau eines leichten, anpassbaren KI-Agenten mit Python, der OpenAI API und einem Cloud-Server (z. B. einem DigitalOcean Droplet oder einer AWS EC2-Instanz). Sie lernen die Anforderungen, die schrittweise Installation und praktische Anwendungsbeispiele kennen. Am Ende haben Sie einen Agenten, der Aufgaben ausführen, Kontext behalten und auf Eingabeaufforderungen reagieren kann – alles in der Cloud laufend.

Anforderungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• **Einen Cloud-Server** (z. B. ein DigitalOcean Droplet für 10 $/Monat mit Ubuntu 22.04 oder eine AWS EC2 t2.micro). Sie benötigen SSH-Zugriff.
• **Python 3.10+** auf dem Server installiert.
• **Einen OpenAI-API-Schlüssel** (oder einen API-Schlüssel von Anthropic, falls Sie Claude verwenden). Holen Sie sich einen von [platform.openai.com](https://platform.openai.com) oder [anthropic.com](https://www.anthropic.com).
• **Grundlegende Vertrautheit mit der Kommandozeile und Python.** Keine fortgeschrittenen KI-Kenntnisse erforderlich.

Schritt-für-Schritt-Installation

Wir bauen einen Agenten, der die OpenAI API verwendet, um auf Benutzeranfragen zu antworten, Python-Code auszuführen und Daten aus dem Web abzurufen. Wir verwenden die Python-Bibliothek `openai` und eine einfache Kommandozeilenschnittstelle.

1. Verbinden Sie sich mit Ihrem Cloud-Server

Öffnen Sie ein Terminal und stellen Sie eine SSH-Verbindung zu Ihrem Server her. Ersetzen Sie `your-server-ip` durch die IP-Adresse Ihres Servers.

ssh root@your-server-ip

Wenn Sie einen Nicht-Root-Benutzer verwenden, passen Sie dies entsprechend an (z. B. `ssh ubuntu@your-server-ip`).

2. Aktualisieren Sie die Systempakete

Aktualisieren Sie die Paketliste und aktualisieren Sie vorhandene Pakete.

sudo apt update && sudo apt upgrade -y

Dadurch wird sichergestellt, dass Sie die neuesten Sicherheitspatches und Bibliotheksversionen haben.

3. Installieren Sie Python und pip

Ubuntu 22.04 wird mit Python 3.10 ausgeliefert. Installieren Sie pip, falls es fehlt.

sudo apt install python3 python3-pip -y

Überprüfen Sie die Installation:

python3 --version
pip3 --version

Sie sollten Python 3.10+ und pip 22+ sehen.

4. Erstellen Sie ein Projektverzeichnis

Erstellen Sie einen dedizierten Ordner für Ihren Agenten.

mkdir ~/ai-agent && cd ~/ai-agent

5. Richten Sie eine virtuelle Umgebung ein

Isolieren Sie Abhängigkeiten, um Konflikte zu vermeiden.

python3 -m venv venv
source venv/bin/activate

Ihre Eingabeaufforderung sollte jetzt `(venv)` anzeigen.

6. Installieren Sie die erforderlichen Python-Bibliotheken

Installieren Sie den OpenAI-Client und einige Hilfsbibliotheken.

pip install openai requests python-dotenv

• `openai`: Offizieller Client für die OpenAI API.
• `requests`: Für HTTP-Aufrufe (z. B. Abrufen von Webdaten).
• `python-dotenv`: Zum Laden des API-Schlüssels aus einer `.env`-Datei.

7. Speichern Sie Ihren API-Schlüssel sicher

Erstellen Sie eine `.env`-Datei im Projektverzeichnis. Hartcodieren Sie Schlüssel niemals in Skripten.

echo "OPENAI_API_KEY=your-api-key-here" > .env

Ersetzen Sie `your-api-key-here` durch Ihren tatsächlichen Schlüssel. Die Datei sollte restriktive Berechtigungen haben:

chmod 600 .env

8. Schreiben Sie das Agenten-Skript

Erstellen Sie eine Datei namens `agent.py`. Dieses Skript wird der Kern Ihres KI-Agenten sein.

#!/usr/bin/env python3
import os
import json
import requests
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def ask_agent(prompt, conversation_history=None):
    if conversation_history is None:
        conversation_history = []
    
    # Systemnachricht hinzufügen, um das Agentenverhalten zu definieren
    messages = [
        {"role": "system", "content": "Sie sind ein hilfreicher KI-Agent. Sie können Fragen beantworten, Code ausführen und Webdaten abrufen. Halten Sie Antworten klar und prägnant."}
    ]
    messages.extend(conversation_history)
    messages.append({"role": "user", "content": prompt})
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",  # Kosteneffizientes Modell
        messages=messages,
        temperature=0.7,
        max_tokens=1000
    )
    
    return response.choices[0].message.content

def main():
    print("KI-Agent (geben Sie 'quit' ein, um zu beenden)")
    history = []
    
    while True:
        user_input = input("\nSie: ").strip()
        if user_input.lower() in ['quit', 'exit']:
            print("Auf Wiedersehen!")
            break
        
        response = ask_agent(user_input, history)
        print(f"Agent: {response}")
        
        # Gesprächskontext speichern
        history.append({"role": "user", "content": user_input})
        history.append({"role": "assistant", "content": response})
        
        # Nur die letzten 10 Austausche behalten, um Token-Limits zu verwalten
        if len(history) > 20:
            history = history[-20:]

if __name__ == "__main__":
    main()

Dieses Skript lädt den API-Schlüssel, definiert eine `ask_agent()`-Funktion, die Eingabeaufforderungen an OpenAI sendet, und führt eine Kommandozeilenschleife aus, die den Gesprächsverlauf beibehält. Die Systemnachricht legt die Persönlichkeit des Agenten fest.

9. Machen Sie das Skript ausführbar

chmod +x agent.py

10. Führen Sie den Agenten aus

python3 agent.py

Sie sehen eine Eingabeaufforderung. Geben Sie eine Frage ein. Zum Beispiel:

Sie: Was ist die Hauptstadt von Frankreich?
Agent: Die Hauptstadt von Frankreich ist Paris.

Drücken Sie Strg+C oder geben Sie `quit` ein, um zu beenden.

Anwendungsbeispiele

Jetzt, wo Ihr Agent läuft, lassen Sie uns praktische Anwendungsfälle erkunden. Der Agent kann erweitert werden, um Code auszuführen, Live-Daten abzurufen und mit APIs zu integrieren.

Beispiel 1: Codeausführung

Modifizieren Sie den Agenten, um Python-Code auszuführen. Fügen Sie diese Funktion zu `agent.py` hinzu:

def execute_code(code):
    """Python-Code ausführen und Ausgabe zurückgeben."""
    try:
        local_vars = {}
        exec(code, {}, local_vars)
        return str(local_vars.get('result', 'Code erfolgreich ausgeführt.'))
    except Exception as e:
        return f"Fehler: {str(e)}"

Erkennen Sie dann in der `ask_agent()`-Funktion, ob der Benutzer eine Codeausführung anfordert. Der Einfachheit halber fügen wir ein spezielles Schlüsselwort hinzu. Aktualisieren Sie die `main()`-Schleife:

if user_input.startswith("!code"):
    code = user_input[6:].strip()
    output = execute_code(code)
    print(f"Agent: {output}")
else:
    response = ask_agent(user_input, history)
    print(f"Agent: {response}")

Jetzt können Sie Code ausführen:

Sie: !code result = 5 + 3
Agent: 8

Beispiel 2: Webdatenabruf

Fügen Sie eine Funktion zum Abrufen und Zusammenfassen von Webinhalten hinzu.

def fetch_url(url):
    """Inhalt von einer URL abrufen."""
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        # Erste 2000 Zeichen zurückgeben
        return response.text[:2000]
    except Exception as e:
        return f"Fehler beim Abrufen der URL: {str(e)}"

Dann in der Hauptschleife:

elif user_input.startswith("!fetch"):
    url = user_input[7:].strip()
    content = fetch_url(url)
    summary = ask_agent(f"Fassen Sie diesen Inhalt zusammen: {content}", history)
    print(f"Agent: {summary}")

Jetzt können Sie den Agenten bitten, Nachrichten abzurufen:

Sie: !fetch https://openai.com/news
Agent: Die OpenAI News-Seite zeigt aktuelle Ankündigungen zu neuen Modellen und Funktionen...

Beispiel 3: Dauerhafter Speicher mit einer Datei

Um Ihrem Agenten ein Langzeitgedächtnis zu geben, speichern Sie den Gesprächsverlauf in einer JSON-Datei.

import json

SAVE_FILE = "memory.json"

def save_memory(history):
    with open(SAVE_FILE, "w") as f:
        json.dump(history, f)

def load_memory():
    try:
        with open(SAVE_FILE, "r") as f:
            return json.load(f)
    except FileNotFoundError:
        return []

Fügen Sie `save_memory(history)` nach jeder Antwort und `history = load_memory()` am Anfang von `main()` hinzu. Jetzt erinnert sich Ihr Agent an vergangene Gespräche, selbst nach einem Neustart.

Beispiel 4: Ausführen als Hintergrunddienst

Um Ihren Agenten dauerhaft laufen zu lassen, verwenden Sie `systemd`. Erstellen Sie eine Servicedatei:

sudo nano /etc/systemd/system/ai-agent.service

Fügen Sie hinzu:

[Unit]
Description=KI-Agenten-Dienst
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root/ai-agent
ExecStart=/root/ai-agent/venv/bin/python /root/ai-agent/agent.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Dann aktivieren und starten:

sudo systemctl daemon-reload
sudo systemctl enable ai-agent
sudo systemctl start ai-agent

Status überprüfen:

sudo systemctl status ai-agent

Jetzt läuft Ihr Agent automatisch beim Booten und startet neu, falls er abstürzt. Sie können Logs mit `journalctl -u ai-agent -f` anzeigen.

Beispiel 5: Integration mit Slack oder Discord

Für einen fortgeschritteneren Anwendungsfall können Sie Ihren Agenten als HTTP-Endpunkt mit Flask oder FastAPI bereitstellen und dann über Webhooks mit Slack verbinden. Dies macht Ihren Agenten zu einem Bot, der in Echtzeit auf Nachrichten antwortet.

Installieren Sie Flask:

pip install flask

Erstellen Sie einen einfachen Webserver (`web_agent.py`):

from flask import Flask, request, jsonify
from agent import ask_agent

app = Flask(__name__)

@app.route("/chat", methods=["POST"])
def chat():
    data = request.json
    prompt = data.get("message", "")
    response = ask_agent(prompt)
    return jsonify({"response": response})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Führen Sie es aus:

python3 web_agent.py &

Jetzt können Sie POST-Anfragen an `http://your-server-ip:5000/chat` mit einem JSON-Body `{"message": "Hallo"}` senden. Verbinden Sie diesen Endpunkt mit Slack über die Slack Events API.

Fazit

Sie haben Ihren eigenen KI-Agenten in der Cloud gebaut und bereitgestellt. Ausgehend von einem nackten Server haben Sie Python installiert, die OpenAI API eingerichtet, einen konversationellen Agenten geschrieben und ihn mit Codeausführung, Webabruf und dauerhaftem Speicher erweitert. Sie haben auch gelernt, wie Sie ihn als Hintergrunddienst ausführen und als API bereitstellen.

Diese Grundlage kann in viele Richtungen erweitert werden:

• Fügen Sie Unterstützung für Anthropics Claude hinzu (siehe Anthropic News für API-Details).
• Integrieren Sie Microsofts Azure KI-Dienste für Unternehmensfunktionen.
• Implementieren Sie Tool-Use-Muster, bei denen der Agent entscheidet, welche Funktion aufgerufen werden soll.
• Fügen Sie eine Weboberfläche mit Gradio oder Streamlit hinzu.

Die wichtigste Erkenntnis: Einen KI-Agenten zu bauen, ist keine Zauberei. Es ist ein strukturierter Prozess des Verknüpfens von APIs, des Verwaltens von Zuständen und des Umgangs mit Randfällen. Mit Cloud-Hosting erhalten Sie Zuverlässigkeit und Skalierbarkeit. Beginnen Sie mit dem einfachen Skript oben und iterieren Sie dann. Ihr Agent wird mit Ihren Anforderungen wachsen.

Jetzt legen Sie los – stellen Sie Ihren Agenten bereit und lassen Sie ihn für Sie arbeiten.