Cost-Monitoring Middleware voor AI en RAG in .NET Core

Het implementeren van AI-functionaliteiten met Large Language Models (LLM's) zoals GPT-4o, Claude 3.5 of Llama 3 introduceert een nieuwe variabele in de operationele kostenvergelijking: tokenverbruik. In tegenstelling tot traditionele API's waar kosten vaak voorspelbaar zijn, zijn LLM-kosten probabilistisch en afhankelijk van het volume.

Het Probleem: De Verborgen Kosten van Intelligentie

In een RAG (Retrieval-Augmented Generation) systeem wordt de kostenuitdaging vergroot. Een enkele gebruikersvraag kan een ophaalstap triggeren die duizenden tokens aan context in de prompt injecteert. Zonder real-time inzicht kunnen verschillende problemen ontstaan:

• Token Burn: Een bug in een recursieve agent-loop kan in enkele minuten duizenden dollars verbruiken.
• Gebrek aan Attributie: Bedrijven kunnen niet eenvoudig zien welke feature, gebruiker of afdeling de AI-kosten veroorzaakt.
• Stille Inefficiëntie: Ongeoptimaliseerde prompts of te enthousiaste ophaalstrategieën kunnen contextruimte verspillen zonder dat iemand het merkt.

Ontwikkelaars hebben een manier nodig om deze kosten te monitoren, te budgetteren en te rapporteren zonder hun bedrijfslogica te vervuilen met prijsberekeningen.

De Oplossing: Een Universele Monitoring Middleware

Met de release van Microsoft.Extensions.AI (beschikbaar in .NET 9 en 10) hebben we een standaardset abstracties voor AI-services. Dit stelt ons in staat om een schoon middleware-patroon te implementeren met de DelegatingChatClient die elke AI-vraag en elk antwoord onderschept.

Stap 1: De Kostenconfiguratie Definiëren

Eerst definiëren we een structuur om de prijzen voor verschillende modellen op te slaan, meestal in appsettings.json.

public record ModelPricing(decimal PricePerMillionInputTokens, decimal PricePerMillionOutputTokens);

public class AiCostOptions
{
    public Dictionary<string, ModelPricing> ModelRates { get; set; } = new()
    {
        { "gpt-4o", new ModelPricing(5.00m, 15.00m) },
        { "gpt-4o-mini", new ModelPricing(0.15m, 0.60m) }
    };
}

Stap 2: De Cost-Monitoring Middleware Implementeren

De CostMonitoringChatClient wrapt elke IChatClient en logt de verbruiksmetadata die door de provider wordt geretourneerd, en stuurt deze naar OpenTelemetry via System.Diagnostics.Metrics.

using Microsoft.Extensions.AI;
using System.Diagnostics.Metrics;

public class CostMonitoringChatClient : DelegatingChatClient
{
    private readonly AiCostOptions _options;
    private readonly Histogram<double> _costHistogram;

    public CostMonitoringChatClient(IChatClient innerClient, AiCostOptions options, IMeterFactory meterFactory) 
        : base(innerClient)
    {
        _options = options;
        var meter = meterFactory.Create("Neneos.AI.Monitoring");
        _costHistogram = meter.CreateHistogram<double>("ai.request.cost", "USD", "Estimated cost of AI request");
    }

    public override async Task<ChatCompletion> CompleteAsync(
        IList<ChatMessage> chatMessages, 
        ChatOptions? options = null, 
        CancellationToken cancellationToken = default)
    {
        var response = await base.CompleteAsync(chatMessages, options, cancellationToken);
        
        ProcessUsage(response.ModelId, response.Usage, options);
        
        return response;
    }

    private void ProcessUsage(string? modelId, UsageDetails? usage, ChatOptions? options)
    {
        if (usage == null || string.IsNullOrEmpty(modelId)) return;

        if (_options.ModelRates.TryGetValue(modelId, out var rates))
        {
            var inputCost = (usage.InputTokenCount / 1_000_000m) * rates.PricePerMillionInputTokens;
            var outputCost = (usage.OutputTokenCount / 1_000_000m) * rates.PricePerMillionOutputTokens;
            var totalCost = (double)(inputCost + outputCost);

            // Emit naar OpenTelemetry voor real-time dashboards
            _costHistogram.Record(totalCost, 
                new KeyValuePair<string, object?>("model", modelId),
                new KeyValuePair<string, object?>("deployment", options?.DeploymentName));
            
            Console.WriteLine($"[AI COST] Model: {modelId} | Kosten: ${totalCost:F6}");
        }
    }
}

Stap 3: Registratie in Program.cs

Het mooie van de nieuwe .NET AI-abstracties is hoe eenvoudig je deze clients in een pipeline kunt koppelen.

builder.Services.AddChatClient(new AzureOpenAIChatClient(...))
    .Use((inner, sp) => new CostMonitoringChatClient(inner, 
        sp.GetRequiredService<IOptions<AiCostOptions>>().Value,
        sp.GetRequiredService<IMeterFactory>()));

Mogelijke Valkuilen en Gevaren

Hoewel monitoring essentieel is, brengt het bouwen van deze systemen technische en operationele risico's met zich mee:

• Prijsvolatiliteit: AI-providers wijzigen hun prijzen regelmatig. Het hardcoderen van tarieven is riskant; overweeg een dynamische configuratieprovider of een externe API voor actuele tarieven.
• Complexiteit van Streaming: Het monitoren van kosten voor streaming-antwoorden is aanzienlijk moeilijker, omdat je gedeeltelijke verbruiksfragmenten moet aggregeren, wat inconsistent kan zijn tussen providers.
• Verschillen tussen Providers: Niet alle providers retourneren verbruiksstatistieken op dezelfde manier (sommige sluiten bijvoorbeeld gecachte tokens uit), wat leidt tot "geschatte" in plaats van "exacte" kosten.
• Performance Overhead: Hoewel minimaal, moet het toevoegen van telemetrielagen aan het kritieke pad van AI-aanroepen zorgvuldig gebeuren om vertraging te voorkomen.

Conclusie: Operationele Uitmuntendheid in het AI-tijdperk

Observability is de hoeksteen van betrouwbare, productieklare systemen. Door cost-monitoring middleware te implementeren, transformeert u uw AI-integraties van een onvoorspelbare "black box" uitgave naar een meetbaar en beheersbaar bedrijfsmiddel. Deze gegevens stellen u in staat om weloverwogen beslissingen te nemen over modelselectie en prompt-optimalisatie, zodat uw AI-functies economisch levensvatbaar blijven terwijl ze schalen.