Kostenkontrolle für KI-Agenten

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Kostenkontrolle für KI-Agenten behandelt

• Wie Du Token-Verbrauch und API-Kosten von KI-Agenten überwachst.
• Wie Du Budgets, Alerts und Limits einrichtest.
• Wie lokale KI API-Kosten eliminiert.
• Praxisbeispiele für Kosten-Tracking, Budget-Warnungen und Optimierung.
• Best Practices für wirtschaftlichen Agenten-Betrieb.

Einleitung: Kostenkontrolle für KI-Agenten verständlich erklärt

KI-Agenten können viel kosten. Jeder Agenten-Schritt ruft das Sprachmodell auf, jeder Aufruf verbraucht Token, jeder Token kostet Geld bei Cloud-APIs. Ein Agent, der 24/7 läuft und 5 Millionen Token pro Tag verbraucht, kann Tausende Euro pro Monat kosten. Kostenkontrolle ist die Disziplin, diesen Verbrauch zu überwachen, zu begrenzen und zu optimieren.

Dieser Artikel richtet sich an Entwicklerinnen und Entwickler, die KI-Agenten bauen und Kosten kontrollieren wollen. Du solltest verstehen, was KI-Agenten sind und wie man sie lokal mit Ollama betreibt. Grundlagen der Python-Programmierung findest Du auf IRC-Coding.de.

Warum brauche ich Kostenkontrolle?

Stell Dir vor, Du baust einen Agenten, der E-Mails sortiert. Der Agent läuft 24/7 und ruft für jede E-Mail das Modell auf. Bei 100 E-Mails pro Tag und 10.000 Token pro Aufruf sind das 1 Million Token pro Tag. Bei GPT-4o (5 $/M Input, 15 $/M Output) sind das 20 $ pro Tag, 600 $ pro Monat. Ohne Kostenkontrolle merkst Du das erst, wenn die Rechnung kommt.

Kostenkontrolle für KI-Agenten kurz erklärt

Kostenkontrolle ist die Überwachung und Begrenzung des Token-Verbrauchs von KI-Agenten. Du misst, wie viele Token jeder Agent verbraucht, setzt Budgets, richtest Alerts ein und optimierst, um Kosten zu senken. Mit lokaler KI (Ollama) entfallen API-Kosten vollständig.

Der Kerngedanke lautet: Was Du nicht misst, kannst Du nicht kontrollieren.

Für wen ist dieser Artikel gedacht?

• Entwicklerinnen und Entwickler, die KI-Agenten bauen und Kosten kontrollieren.
• Teams, die Agenten im Produktivbetrieb haben und Budgets einhalten müssen.
• Entscheiderinnen und Entscheider, die API-Kosten nachvollziehen wollen.
• Self-Hoster, die lokale KI als Kostenalternative bewerten.

Vorkenntnisse in KI-Agenten und Ollama sind hilfreich.

Wichtige Begriffe

• Token - Einheit für Text, ca. 4 Zeichen. Wann nützlich: die Abrechnungseinheit bei APIs.
• KI-Agenten - Programme, die Modelle aufrufen. Wann nützlich: was Kosten verursacht.
• Ollama - Lokaler Modellserver. Wann nützlich: eliminiert API-Kosten.
• Budget - Kostenlimit pro Zeitraum. Wann nützlich: um Ausgaben zu begrenzen.
• Alert - Warnung bei Budget-Überschreitung. Wann nützlich: um rechtzeitig einzugreifen.
• Quantisierung - Reduzierung der Modellgröße. Wann nützlich: um schnellere, günstigere Inferenz.
• Kontextlänge - Maximale Token pro Aufruf. Wann nützlich: beeinflusst Kosten.
• Protokollierung - Aufzeichnung von Aufrufen. Wann nützlich: Basis für Kosten-Tracking.

Token-Verbrauch messen

Cloud-API: Token aus Response

Bei Cloud-APIs gibt die Antwort die Token-Anzahl zurück:

import requests

def call_model_with_tracking(messages):
    response = requests.post(
        "https://api.openai.com/v1/chat/completions",
        headers={"Authorization": "Bearer sk-..."},
        json={
            "model": "gpt-4o",
            "messages": messages,
            "stream": False
        }
    )
    data = response.json()
    return {
        "content": data["choices"][0]["message"]["content"],
        "input_tokens": data["usage"]["prompt_tokens"],
        "output_tokens": data["usage"]["completion_tokens"],
        "cost": calculate_cost("gpt-4o", data["usage"])
    }

def calculate_cost(model, usage):
    prices = {
        "gpt-4o": {"input": 5.0, "output": 15.0},  # pro 1M Token
        "gpt-4o-mini": {"input": 0.15, "output": 0.60},
        "claude-3-5-sonnet": {"input": 3.0, "output": 15.0}
    }
    p = prices.get(model, {"input": 0, "output": 0})
    return (usage["prompt_tokens"] * p["input"] + usage["completion_tokens"] * p["output"]) / 1_000_000

Ollama: Token aus Response

Ollama gibt ebenfalls Token-Anzahlen zurück:

def call_ollama_with_tracking(messages):
    response = requests.post(
        "http://localhost:11434/api/chat",
        json={"model": "llama3.1", "messages": messages, "stream": False}
    )
    data = response.json()
    return {
        "content": data["message"]["content"],
        "input_tokens": data.get("prompt_eval_count", 0),
        "output_tokens": data.get("eval_count", 0),
        "cost": 0.0  # Lokale KI: keine API-Kosten
    }

Kosten-Tracker implementieren

from datetime import datetime, timedelta
from collections import defaultdict
import json

class CostTracker:
    def __init__(self, log_file="agent_costs.json"):
        self.log_file = log_file
        self.costs = defaultdict(lambda: {"input_tokens": 0, "output_tokens": 0, "cost": 0.0, "calls": 0})

    def log_call(self, agent_id, model, input_tokens, output_tokens, cost):
        entry = {
            "timestamp": datetime.now().isoformat(),
            "agent_id": agent_id,
            "model": model,
            "input_tokens": input_tokens,
            "output_tokens": output_tokens,
            "cost": cost
        }
        self.costs[agent_id]["input_tokens"] += input_tokens
        self.costs[agent_id]["output_tokens"] += output_tokens
        self.costs[agent_id]["cost"] += cost
        self.costs[agent_id]["calls"] += 1

        with open(self.log_file, "a") as f:
            f.write(json.dumps(entry) + "\n")

    def get_daily_cost(self, agent_id=None):
        today = datetime.now().date()
        total = 0.0
        with open(self.log_file) as f:
            for line in f:
                entry = json.loads(line)
                entry_date = datetime.fromisoformat(entry["timestamp"]).date()
                if entry_date == today:
                    if agent_id is None or entry["agent_id"] == agent_id:
                        total += entry["cost"]
        return total

    def get_monthly_cost(self, agent_id=None):
        now = datetime.now()
        total = 0.0
        with open(self.log_file) as f:
            for line in f:
                entry = json.loads(line)
                entry_date = datetime.fromisoformat(entry["timestamp"])
                if entry_date.year == now.year and entry_date.month == now.month:
                    if agent_id is None or entry["agent_id"] == agent_id:
                        total += entry["cost"]
        return total

    def summary(self):
        return {agent: dict(stats) for agent, stats in self.costs.items()}

Budgets und Alerts

class BudgetGuard:
    def __init__(self, tracker, daily_budget=10.0, monthly_budget=200.0):
        self.tracker = tracker
        self.daily_budget = daily_budget
        self.monthly_budget = monthly_budget

    def check_budget(self, agent_id=None):
        daily = self.tracker.get_daily_cost(agent_id)
        monthly = self.tracker.get_monthly_cost(agent_id)

        if daily > self.daily_budget:
            self.send_alert("daily", daily, self.daily_budget, agent_id)
            return False

        if monthly > self.monthly_budget:
            self.send_alert("monthly", monthly, self.monthly_budget, agent_id)
            return False

        # Warnung bei 80% Auslastung
        if daily > self.daily_budget * 0.8:
            self.send_warning("daily", daily, self.daily_budget, agent_id)
        if monthly > self.monthly_budget * 0.8:
            self.send_warning("monthly", monthly, self.monthly_budget, agent_id)

        return True

    def send_alert(self, budget_type, actual, budget, agent_id):
        print(f"ALERT: {budget_type} budget exceeded!")
        print(f"Agent: {agent_id or 'all'}")
        print(f"Actual: {actual:.2f} $, Budget: {budget:.2f} $")
        # In Praxis: E-Mail, Slack, Webhook

    def send_warning(self, budget_type, actual, budget, agent_id):
        print(f"WARNING: {budget_type} budget at 80%!")
        print(f"Agent: {agent_id or 'all'}")
        print(f"Actual: {actual:.2f} $, Budget: {budget:.2f} $")

Agent mit Kostenkontrolle

class CostControlledAgent:
    def __init__(self, model="gpt-4o", tracker=None, budget_guard=None):
        self.model = model
        self.tracker = tracker or CostTracker()
        self.budget_guard = budget_guard or BudgetGuard(self.tracker)

    def call_model(self, messages, agent_id="default"):
        # Budget prüfen
        if not self.budget_guard.check_budget(agent_id):
            raise BudgetExceededError("Budget überschritten, Aufruf abgelehnt")

        # Modell aufrufen
        result = call_model_with_tracking(messages)
        result["agent_id"] = agent_id

        # Kosten protokollieren
        self.tracker.log_call(
            agent_id=agent_id,
            model=self.model,
            input_tokens=result["input_tokens"],
            output_tokens=result["output_tokens"],
            cost=result["cost"]
        )

        return result["content"]

class BudgetExceededError(Exception):
    pass

Praxisbeispiel 1: E-Mail-Agent mit Budget

tracker = CostTracker()
guard = BudgetGuard(tracker, daily_budget=5.0, monthly_budget=100.0)
agent = CostControlledAgent(model="gpt-4o-mini", tracker=tracker, budget_guard=guard)

for email in emails:
    try:
        result = agent.call_model(
            [{"role": "user", "content": f"Klassifiziere: {email['subject']}"}],
            agent_id="email_classifier"
        )
    except BudgetExceededError:
        print("Budget überschritten, schalte auf lokales Modell um")
        # Fallback auf Ollama
        result = call_ollama_with_tracking([
            {"role": "user", "content": f"Klassifiziere: {email['subject']}"}
        ])

Praxisbeispiel 2: Multi-Agent mit verteiltem Budget

# Verschiedene Budgets pro Agent
budgets = {
    "email_classifier": BudgetGuard(tracker, daily_budget=2.0, monthly_budget=50.0),
    "research_agent": BudgetGuard(tracker, daily_budget=10.0, monthly_budget=200.0),
    "writer_agent": BudgetGuard(tracker, daily_budget=5.0, monthly_budget=100.0)
}

agents = {
    name: CostControlledAgent(model="gpt-4o-mini", tracker=tracker, budget_guard=guard)
    for name, guard in budgets.items()
}

Kosten optimieren

1. Kleines Modell für einfache Aufgaben

# Für Klassifikation: gpt-4o-mini statt gpt-4o
# Ersparnis: 0,15 $/M statt 5 $/M Input = 97% günstiger

2. Kontextlänge begrenzen

# Nicht ganze E-Mail-Threads senden, nur die letzte Nachricht
messages = messages[-3:]  # Nur letzte 3 Nachrichten

3. Caching

from functools import lru_cache

@lru_cache(maxsize=1000)
def cached_classification(email_hash):
    # Gleiche E-Mails nicht zweimal klassifizieren
    return call_model_with_tracking([{"role": "user", "content": email_hash}])

4. Lokale KI für Standard-Aufgaben

# Standard-Aufgaben mit Ollama (kostenlos)
# Komplexe Aufgaben mit Cloud-API (kostenpflichtig)

def smart_router(task_complexity):
    if task_complexity == "simple":
        return call_ollama_with_tracking  # Kostenlos
    else:
        return call_model_with_tracking  # Cloud

Siehe Lokale KI vs. API-Kosten für Details.

5. Batch-Verarbeitung

# Mehrere Anfragen in einem Aufruf bündeln
batch_prompt = "Klassifiziere folgende E-Mails:\n" + "\n".join(
    f"{i+1}. {email}" for i, email in enumerate(emails)
)
# Ein Aufruf statt 100

Typische Stolpersteine

• Kein Tracking: Ohne Messung keine Kontrolle. Implementiere von Anfang an.
• Falsches Modell: GPT-4o für einfache Klassifikation ist Verschwendung.
• Keine Budgets: Ohne Limits kann ein fehlerhafter Agent Tausende Euro kosten.
• Keine Alerts: Ohne Warnung merkst Du Budget-Überschreitung erst bei der Rechnung.
• Kontextlänge ignoriert: Lange Kontexte kosten mehr. Begrenze wo möglich.
• Kein Caching: Gleiche Anfragen mehrfach auszuführen, ist Verschwendung.

Weiterführende Links

• KI-Agenten Grundlagen - Was KI-Agenten sind.
• KI-Agenten mit Ollama - Lokale KI ohne API-Kosten.
• Protokollierung - Basis für Kosten-Tracking.
• Lokale KI vs. API-Kosten - Kostenvergleich.
• Quantisierung - Modellgröße reduzieren.
• Kontextlänge - Kontext verstehen.
• Cloud-Kostenrechner - API-Kosten berechnen.
• Stromkostenrechner - Stromkosten für lokale KI.

Key Takeaways:

• Kostenkontrolle misst Token-Verbrauch und API-Kosten.
• Budgets und Alerts verhindern Kostenexplosionen.
• Kleine Modelle für einfache Aufgaben sparen bis zu 97%.
• Caching vermeidet doppelte Aufrufe.
• Lokale KI (Ollama) eliminiert API-Kosten vollständig.

FAQ

Quellen und weiterführende Literatur

• OpenAI Pricing - API-Preise.
• Ollama - Lokaler Modellserver.
• Cloud-Kostenrechner - API-Kosten berechnen.
• Lokale KI vs. API-Kosten - Kostenvergleich.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert