Alle LLM-API-Aufrufe an einem Ort ueberwachen und protokollieren

Einheitliches Logging fuer OpenAI, Anthropic, Google und Azure. Sehen Sie jede Anfrage, Antwort, Token-Anzahl und Latenz — mit einem einzigen Proxy. Kein eigener Logging-Code noetig.

Das Problem: verteilte Anbieter, verteilte Logs

Sie rufen OpenAI fuer Chat auf, Anthropic fuer Code-Reviews, Google fuer Embeddings und Azure fuer ein feinabgestimmtes Modell. Jeder Anbieter hat seine eigene Logging-Geschichte — und die meisten haben ueberhaupt keine.

// Four providers. Zero unified view of what's happening.
await openai.chat.completions.create({ model: "gpt-4o", messages });
await anthropic.messages.create({ model: "claude-sonnet-4-5-20250514", messages });
await google.generateContent({ model: "gemini-2.0-flash", contents });
await azure.chat.completions.create({ model: "gpt-4o", messages });

Wenn ein Prompt eine schlechte Antwort liefert, koennen Sie nicht nachvollziehen, was gesendet wurde. Wenn die Latenz steigt, koennen Sie nicht erkennen, welches Modell langsam ist. Wenn ein Kunde einen Fehler meldet, raten Sie — weil die eigentliche Anfrage und Antwort nirgendwo durchsuchbar protokolliert sind.

Anbieter-Dashboards zeigen aggregierte Metriken. Sie zeigen Ihnen nicht den Prompt, der gestern um 15:47 Uhr die Halluzination verursacht hat.

Die Loesung: einheitliches Logging mit Grepture

Grepture ist ein AI Gateway, das zwischen Ihrer Anwendung und jedem LLM-Anbieter sitzt. Jede Anfrage, die durch den Proxy fliesst, wird automatisch protokolliert — Request Body, Response Body, Token-Anzahl, Latenz, HTTP-Status, Modell und welche Erkennungsregeln ausgeloest wurden.

Keine eigene Logging-Middleware. Kein console.log(JSON.stringify(messages)). Leiten Sie Ihren Traffic ueber den Proxy und jeder Aufruf wird in einem einzigen, durchsuchbaren Traffic Log erfasst.

Einrichtung in 3 Minuten

1. SDK installieren

npm install @grepture/sdk

2. API Key erhalten

Registrieren Sie sich unter grepture.com/en/pricing — der kostenlose Plan umfasst 1.000 Anfragen/Monat. Kopieren Sie Ihren API Key aus dem Dashboard.

3. AI-Traffic ueber den Proxy leiten

OpenAI

import OpenAI from "openai";
import { Grepture } from "@grepture/sdk";

const grepture = new Grepture({
  apiKey: process.env.GREPTURE_API_KEY!,
  proxyUrl: "https://proxy.grepture.com",
});

const openai = new OpenAI({
  ...grepture.clientOptions({
    apiKey: process.env.OPENAI_API_KEY!,
    baseURL: "https://api.openai.com/v1",
  }),
});

// Every request is now logged automatically
const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Summarize this document..." }],
});

Anthropic

const anthropic = new OpenAI({
  ...grepture.clientOptions({
    apiKey: process.env.ANTHROPIC_API_KEY!,
    baseURL: "https://api.anthropic.com/v1",
  }),
});

Google Gemini

const gemini = new OpenAI({
  ...grepture.clientOptions({
    apiKey: process.env.GEMINI_API_KEY!,
    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai",
  }),
});

Azure OpenAI

const azure = new OpenAI({
  ...grepture.clientOptions({
    apiKey: process.env.AZURE_OPENAI_API_KEY!,
    baseURL: "https://your-resource.openai.azure.com/openai/deployments/your-deployment",
  }),
});

Beliebige HTTP API

Fuer Anbieter ohne OpenAI-kompatibles SDK verwenden Sie grepture.fetch():

const response = await grepture.fetch("https://api.example.com/v1/generate", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${process.env.PROVIDER_API_KEY}`,
  },
  body: JSON.stringify({ prompt: "..." }),
});

Was protokolliert wird

Jede Anfrage ueber den Proxy erfasst:

  • Request und Response Body — der vollstaendige Prompt und die Completion, im Dashboard einsehbar
  • Token-Anzahl — Input-Tokens, Output-Tokens und Gesamtzahl fuer jeden Aufruf
  • Latenz — Round-Trip-Zeit von Ihrer App zum Anbieter und zurueck
  • HTTP-Status — Erfolg, Rate Limit, Authentifizierungsfehler, Timeout
  • Modell — welches Modell die Anfrage verarbeitet hat
  • Ausgeloeste Erkennungsregeln — welche Grepture-Regeln ausgeloest wurden (PII, Geheimnisse, Prompt Injection)
  • Request ID — eindeutiger Identifikator fuer jeden Aufruf, im Code ueber requestId in der Antwort verfuegbar

Sie koennen Erkennungs-Metadaten auch programmatisch abrufen:

const response = await grepture.fetch("https://api.openai.com/v1/chat/completions", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.OPENAI_API_KEY}` },
  body: JSON.stringify({ model: "gpt-4o", messages }),
});

console.log(response.requestId);    // "req_abc123..."
console.log(response.rulesApplied); // ["pii-email", "pii-phone"]

Das Traffic Log verwenden

Die Traffic Log-Seite im Dashboard ist der Ort, an dem Sie die meiste Zeit verbringen werden:

  • Filterbare Tabelle — Suche nach Statuscode, HTTP-Methode, Modell, URL oder Zeitfenster
  • Request-Detailansicht — klicken Sie auf eine Zeile, um die vollstaendige Anfrage und Antwort zu sehen, einschliesslich Header, Body, Token-Anzahl, Latenz und ausgeloeste Regeln
  • 30-Tage-Traffic-Diagramm — erkennen Sie Trends, Spitzen und Anomalien auf einen Blick

Fuer Organisationen, die Logging ohne Speicherung von Prompt-Inhalten benoetigen, erfasst der Zero-Data-Modus (Business+) betriebliche Metadaten — Status, Tokens, Latenz, Modell — ohne Request- oder Response-Bodys zu speichern.

Conversation Tracing

AI Agents und Multi-Turn-Konversationen fuehren Dutzende von LLM-Aufrufen pro Benutzerinteraktion durch. Ohne Gruppierung sind sie nur Rauschen in einem flachen Log. Verwenden Sie Trace IDs, um zusammengehoerige Anfragen in einer einzigen Zeitleiste zu verknuepfen.

Trace ID bei der Erstellung setzen

const grepture = new Grepture({
  apiKey: process.env.GREPTURE_API_KEY!,
  proxyUrl: "https://proxy.grepture.com",
  traceId: `session-${crypto.randomUUID().slice(0, 12)}`,
});

const openai = new OpenAI({
  ...grepture.clientOptions({
    apiKey: process.env.OPENAI_API_KEY!,
    baseURL: "https://api.openai.com/v1",
  }),
});

// Both calls are grouped under the same trace
await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Plan the migration steps." }],
});

await openai.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Execute step 1..." }],
});

Trace waehrend der Sitzung aendern

Wenn eine neue Konversation beginnt oder ein Agent einen separaten Lauf startet, wechseln Sie den Trace:

// New user session — new trace
grepture.setTraceId(`session-${crypto.randomUUID().slice(0, 12)}`);

// Stop tracing
grepture.setTraceId(undefined);

Im Traces-Tab des Dashboards sehen Sie alle Anfragen gruppiert nach Trace mit einer kombinierten Zeitleiste, der Gesamt-Token-Anzahl und der aggregierten Latenz. So wird eine Wand einzelner Anfragen zu einer lesbaren Konversationshistorie.

Framework-Integration

LangChain

Wrappen Sie den zugrunde liegenden OpenAI-Client, den LangChain verwendet:

import { ChatOpenAI } from "@langchain/openai";
import { Grepture } from "@grepture/sdk";

const grepture = new Grepture({
  apiKey: process.env.GREPTURE_API_KEY!,
  proxyUrl: "https://proxy.grepture.com",
});

const model = new ChatOpenAI({
  modelName: "gpt-4o",
  ...grepture.clientOptions({
    apiKey: process.env.OPENAI_API_KEY!,
    baseURL: "https://api.openai.com/v1",
  }),
});

Jeder LangChain-Aufruf — Chains, Agents, Tools — fliesst nun ueber den Proxy und erscheint in Ihrem Traffic Log.

Vercel AI SDK

import { createOpenAI } from "@ai-sdk/openai";
import { Grepture } from "@grepture/sdk";

const grepture = new Grepture({
  apiKey: process.env.GREPTURE_API_KEY!,
  proxyUrl: "https://proxy.grepture.com",
});

const openai = createOpenAI({
  ...grepture.clientOptions({
    apiKey: process.env.OPENAI_API_KEY!,
    baseURL: "https://api.openai.com/v1",
  }),
});

Naechste Schritte