Control de costos para agentes de IA

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo sobre control de costos para agentes de IA

• Cómo monitorear el consumo de tokens y los costos de API de agentes de IA.
• Cómo configurar presupuestos, alertas y límites.
• Cómo eliminar costos de API con IA local.
• Ejemplos prácticos de seguimiento de costos, advertencias presupuestarias y optimización.
• Mejores prácticas para operar agentes de forma económica.

Introducción: Control de costos para agentes de IA explicado de forma clara

Los agentes de IA pueden resultar muy costosos. Cada paso del agente invoca el modelo de lenguaje, cada invocación consume tokens, cada token cuesta dinero en APIs en la nube. Un agente que funciona 24/7 y consume 5 millones de tokens al día puede costar miles de euros al mes. El control de costos es la disciplina de monitorear, limitar y optimizar este consumo.

Este artículo está dirigido a desarrolladores que construyen agentes de IA y quieren controlar costos. Deberías entender qué son los agentes de IA y cómo operarlos localmente con Ollama. Puedes encontrar los fundamentos de programación en Python en IRC-Coding.de.

Por qué necesito control de costos

Imagina que construyes un agente que clasifica correos electrónicos. El agente funciona 24/7 e invoca el modelo para cada correo. Con 100 correos al día y 10.000 tokens por invocación, son 1 millón de tokens al día. Con GPT-4o (5 $/M entrada, 15 $/M salida), esto representa 20 $ al día, 600 $ al mes. Sin control de costos, te enteras cuando llega la factura.

Control de costos para agentes de IA en pocas palabras

El control de costos es el monitoreo y limitación del consumo de tokens de agentes de IA. Mides cuántos tokens consume cada agente, estableces presupuestos, configuras alertas y optimizas para reducir costos. Con IA local (Ollama), los costos de API desaparecen completamente.

El concepto fundamental es simple: lo que no mides, no puedes controlar.

Para quién es este artículo

• Desarrolladores que construyen agentes de IA y necesitan controlar costos.
• Equipos que tienen agentes en producción y deben ceñirse a presupuestos.
• Tomadores de decisiones que quieren entender los costos de API.
• Usuarios de soluciones locales que evalúan IA local como alternativa económica.

El conocimiento previo de agentes de IA y Ollama es útil.

Términos importantes

• Token - Unidad de texto, aproximadamente 4 caracteres. Útil para: la unidad de facturación en APIs.
• Agentes de IA - Programas que invocan modelos. Útil para: lo que genera costos.
• Ollama - Servidor de modelos local. Útil para: elimina costos de API.
• Presupuesto - Límite de costo por período. Útil para: controlar gastos.
• Alerta - Advertencia cuando se excede el presupuesto. Útil para: intervenir a tiempo.
• Cuantización - Reducción del tamaño del modelo. Útil para: inferencia más rápida y económica.
• Longitud de contexto - Máximo de tokens por invocación. Útil para: afecta los costos.
• Registros - Grabación de invocaciones. Útil para: base del seguimiento de costos.

Medir el consumo de tokens

API en la nube: tokens de la respuesta

Las APIs en la nube devuelven la cantidad de tokens en la respuesta:

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: tokens de la respuesta

Ollama también devuelve cantidades de tokens:

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  # IA local: sin costos de API
    }

Implementar un rastreador de costos

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

Presupuestos y alertas

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

        # Advertencia al 80% de consumo
        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} $")
        # En producción: correo, 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} $")

Agente con control de costos

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

Caso práctico 1: Agente de correo electrónico con presupuesto

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

Caso práctico 2: Multi-agente con presupuesto distribuido

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

Optimización de costos

1. Modelo pequeño para tareas simples

# Para clasificación: gpt-4o-mini en lugar de gpt-4o
# Ahorro: 0,15 $/M frente a 5 $/M entrada = 97% más barato

2. Limitar la longitud del contexto

# No enviar hilos de correo completos, solo el último mensaje
messages = messages[-3:]  # Solo los últimos 3 mensajes

3. Almacenamiento en caché

from functools import lru_cache

@lru_cache(maxsize=1000)
def cached_classification(email_hash):
    # No clasificar el mismo correo dos veces
    return call_model_with_tracking([{"role": "user", "content": email_hash}])

4. IA local para tareas estándar

# Tareas estándar con Ollama (gratuito)
# Tareas complejas con API en la nube (pago)

def smart_router(task_complexity):
    if task_complexity == "simple":
        return call_ollama_with_tracking  # Gratuito
    else:
        return call_model_with_tracking  # Nube

Consulta IA local vs. costos de API para más detalles.

5. Procesamiento por lotes

# Agrupar múltiples solicitudes en una sola llamada
batch_prompt = "Klassifiziere folgende E-Mails:\n" + "\n".join(
    f"{i+1}. {email}" for i, email in enumerate(emails)
)
# Una llamada en lugar de 100

Escollos típicos

• Sin seguimiento: Sin medición no hay control. Implementa desde el principio.
• Modelo incorrecto: Usar GPT-4o para clasificación simple es un derroche.
• Sin presupuestos: Sin límites, un agente defectuoso puede costar miles de euros.
• Sin alertas: Sin notificación, descubrirás el exceso de presupuesto en la factura.
• Ignorar la longitud del contexto: Los contextos largos cuestan más. Limita donde sea posible.
• Sin caché: Ejecutar las mismas solicitudes varias veces es un derroche.

Enlaces adicionales

• Fundamentos de agentes de IA - Qué son los agentes de IA.
• Agentes de IA con Ollama - IA local sin costos de API.
• Protocolo - Base para el seguimiento de costos.
• IA local vs. costos de API - Comparación de costos.
• Cuantización - Reducir el tamaño del modelo.
• Longitud del contexto - Entender el contexto.
• Calculadora de costos en la nube - Calcular costos de API.
• Calculadora de costos de energía - Costos de energía para IA local.

Puntos clave:

• El control de costos mide el consumo de tokens y los costos de API.
• Los presupuestos y las alertas evitan explosiones de costos.
• Los modelos pequeños para tareas simples ahorran hasta el 97%.
• El almacenamiento en caché evita llamadas duplicadas.
• La IA local (Ollama) elimina completamente los costos de API.

Preguntas frecuentes

Fuentes y lecturas adicionales

• OpenAI Pricing - Precios de la API.
• Ollama - Servidor local de modelos.
• Cloud-Kostenrechner - Calcula costos de API.
• Lokale KI vs. API-Kosten - Comparativa de costos.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert