Anwendungsfälle

Jedes Rezept nennt das Ziel, den Weg (MCP-Server, API oder beides), funktionierenden Code, was es bei unserem Testlauf gekostet hat und wie privat es ist. Einmalige Einrichtung:

export CARPE_API_KEY=cdm_your_key   # API → Keys
pip install openai requests          # Python recipes

Die Kosten unten wurden am 2026-11-06 gemessen und bewegen sich mit dem dynamischen Preis. Bevor du etwas Großes ausführst, hol dir ein Angebot – das ist kostenlos: POST /router/quote für Text, POST /v1/video/quote für Video, /pricing für alles andere.

Das günstigste Modell für eine Aufgabe

Ziel: eine ausreichend gute Antwort zum niedrigsten Preis, ohne Modelle von Hand zu testen.

Mit dem MCP-Server führst du den Prompt cheapest_model_for aus oder fragst einfach: „Finde das günstigste Modell, das das gut ins Deutsche übersetzen kann, und übersetze es dann.“ Der Assistent wählt passende Modelle aus, holt für jedes mit carpe_quote (kostenlos) ein Angebot auf /v1 und /router ein, führt das günstigste brauchbare aus und sagt dir, was es gekostet hat und wer es bedient hat.

Mit der API holst du zuerst ein Angebot ein und schickst die Anfrage dann an den Router – er wählt den günstigsten Markt selbst:

import os, requests
from openai import OpenAI
 
BASE = "https://carpe-diem.xyz/api/operator"
 
# 1. Free quote: what would 500 tokens in / 300 out cost, on each market?
q = requests.post(f"{BASE}/router/quote", json={"model": "deepseek-v4-flash", "input_tokens": 500, "max_tokens": 300}).json()
print("best:", q["best"]["market"], q["best"]["costUsd"], "USD")
 
# 2. Run it through the router: the cheapest market serves it.
client = OpenAI(base_url=f"{BASE}/router", api_key=os.environ["CARPE_API_KEY"])
raw = client.chat.completions.with_raw_response.create(
    model="deepseek-v4-flash",
    messages=[{"role": "user", "content": "Translate into German: The meeting moved to Thursday."}],
)
print(raw.parse().choices[0].message.content)
print("served by", raw.headers.get("x-carpe-route-market"), "for", raw.headers.get("x-carpe-route-cost-usdc"), "USDC")

Kosten: 0,00003 $ für diese Übersetzung (bei unserem Testlauf von OpenRouter bedient). Privatsphäre: Der Router kann sie außerhalb des TEE bedienen; füge extra_body={"privacy": True} hinzu, um auf TEE-Märkten zu bleiben.

Vertrauliche Analyse im TEE

Ziel: einen Vertrag, einen Arztbrief oder internen Code zusammenfassen, ohne dass irgendjemand ihn speichert.

Nutze den Zugang /v1 (immer über das TEE von Carpe) und ein Modell, das in /v1/models als privacy: "private" gelistet ist – Venice führt diese aus, ohne Prompts oder Antworten zu speichern.

Mit dem MCP-Server führst du den Prompt private_inference aus oder fragst: „Fasse ./contract.txt privat, nur im TEE, in fünf Stichpunkten zusammen.“ Das Ergebnis meldet tee: true.

import os, requests
from openai import OpenAI
 
BASE = "https://carpe-diem.xyz/api/operator"
models = requests.get(f"{BASE}/v1/models").json()["data"]
private = [m["id"] for m in models if m.get("carpe_diem_type") == "text" and m.get("privacy") == "private"]
print(len(private), "private text models, e.g.", private[:3])
 
client = OpenAI(base_url=f"{BASE}/v1", api_key=os.environ["CARPE_API_KEY"])
document = "This agreement is made between Alpha SA and Beta GmbH. Term: 24 months. Either party may terminate with 90 days' notice."
r = client.chat.completions.create(
    model="deepseek-v4-flash",                       # listed "private"
    messages=[
        {"role": "system", "content": "You summarise legal documents in five short bullet points."},
        {"role": "user", "content": document},
    ],
)
print(r.choices[0].message.content)

Kosten: 0,0001 $ für diese Zusammenfassung; rechne mit etwa 0,0005 $ für eine ganze Seite. Privatsphäre: TEE durchgehend auf Seiten von Carpe und ein Modell, das nichts speichert. Die e2ee-*-Modelle gehen noch weiter (Ende-zu-Ende-verschlüsselt bis in die eigene Enclave des Modells). Prüfe die Attestierung unter /attestation und auf der Seite Privacy.

Ein günstigerer Coding-Agent

Ziel: deinen Coding-Agent behalten und pro Aufgabe weniger zahlen.

Richte den Agent auf Carpe aus und wähle ein Modell nach Preis und Können: Claude-Modelle für die schwierigste Arbeit, kimi-k2-7-code, qwen3-coder-480b-a35b-instruct-turbo oder deepseek-v4-pro für den Großteil. Schritt-für-Schritt-Einrichtung für Claude Code, OpenCode, Aider, Cline, Continue, Zed und VS Code: Coding-Agents.

Gib demselben Agent den MCP-Server, und er kann auch die Assets erzeugen, die dein Projekt braucht – Icons, Mock-ups, Voice-overs –, ohne das Terminal zu verlassen.

Kosten: Du zahlst pro Token zum Preis von Carpe, live angezeigt auf der Seite Models; der API-Bereich zeigt, was jeder Key ausgegeben hat. Privatsphäre: Nimm für proprietären Code lieber ein private-Modell; Claude-Modelle sind anonymized.

Bilder: generieren, bearbeiten, hochskalieren

Ziel: ein Hero-Bild für eine Seite, dann eine Variante, dann eine Version in Druckgröße.

Mit dem MCP-Server: „Generiere eine flache 16:9-Illustration eines roten Fuchses im Wald, mach den Fuchs dann blau und skaliere das Bild anschließend ×2 hoch. Speichere alles in ./assets.“ – carpe_image_generate, carpe_image_edit, carpe_image_upscale.

import base64, os, time, requests
 
BASE = "https://carpe-diem.xyz/api/operator/v1"
H = {"Authorization": f"Bearer {os.environ['CARPE_API_KEY']}"}
 
def queued(path, body):
    """Queue a slow image job, poll until the image comes back (binary)."""
    qid = requests.post(f"{BASE}/{path}/queue", headers=H, json=body).json()["queue_id"]
    while True:
        r = requests.post(f"{BASE}/{path}/retrieve", headers=H, json={"queue_id": qid})
        if r.headers.get("content-type", "").startswith("image/"):
            return r.content
        if r.json().get("status") != "pending":
            raise RuntimeError(r.text)
        time.sleep(2)
 
# 1. Generate (synchronous for fast models) → base64 WebP
gen = requests.post(f"{BASE}/image/generate", headers=H, json={
    "model": "z-image-turbo", "prompt": "a red fox in a forest, flat illustration",
}).json()
fox = gen["images"][0]
open("fox.webp", "wb").write(base64.b64decode(fox))
 
# 2. Edit (queued: edit models take longer) — the source goes in as a data URI
blue = queued("image/edit", {
    "model": "qwen-image-2-1-turbo-edit", "prompt": "make the fox blue",
    "image": f"data:image/webp;base64,{fox}",
})
open("fox-blue.png", "wb").write(blue)
 
# 3. Upscale ×2: raw base64, no data: prefix
up = requests.post(f"{BASE}/image/upscale", headers=H, json={
    "model": "upscaler", "image": base64.b64encode(blue).decode(), "scale": 2,
}, timeout=180)
up.raise_for_status()
open("fox-blue-2x.png", "wb").write(up.content)
print("cost of the last step:", up.headers.get("x-carpe-cost-usdc-micro"), "µUSDC")

Kosten: etwa 0,005 $ fürs Generieren, 0,011 $ fürs Bearbeiten und 0,011 $ fürs Hochskalieren ×2. Privatsphäre: auf /v1, über das TEE. Ein Modell, das für eine einzelne Anfrage zu langsam ist, antwortet mit 409 MODEL_REQUIRES_ASYNC und dem zu verwendenden Endpoint: Der Helper queued() oben funktioniert für image/generate, image/edit und image/multi-edit (Queue-Referenz).

Ein kurzer Videoclip

Ziel: ein 5-Sekunden-Clip für einen Post oder eine Landingpage.

Mit dem MCP-Server: „Mach einen 5-Sekunden-Clip im Format 16:9 von einem Papierboot auf einem ruhigen See. Hol vorher ein Angebot ein.“ – carpe_video_generate holt das Angebot ein und stellt den Job in die Queue, dann wartet carpe_video_status und speichert die MP4.

import os, time, requests
 
BASE = "https://carpe-diem.xyz/api/operator"
H = {"Authorization": f"Bearer {os.environ['CARPE_API_KEY']}"}
job = {"model": "grok-imagine-1-5-lite-text-to-video", "prompt": "a paper boat on a calm lake, morning light",
       "duration": "5s", "aspect_ratio": "16:9"}
 
print("quote:", requests.post(f"{BASE}/v1/video/quote", headers=H, json=job).json()["cost_usdc"], "USD")
qid = requests.post(f"{BASE}/v1/video/queue", headers=H, json=job).json()["queue_id"]
 
while True:
    r = requests.post(f"{BASE}/v1/video/retrieve", headers=H, json={"queue_id": qid}).json()
    if r["status"] == "completed":
        url = r.get("video_url") or r.get("url")
        video = requests.get(url if url.startswith("http") else BASE + url)   # kept ~10 minutes
        open("boat.mp4", "wb").write(video.content)
        break
    if r["status"] == "failed":
        raise RuntimeError(r)
    time.sleep(5)

Kosten: 0,097 $ für diese 5 Sekunden, genau wie im Angebot (die Modelle reichen von Cents bis zu Dollars: immer zuerst ein Angebot einholen). Dauern, Seitenverhältnisse und Auflösungen unterscheiden sich je nach Modell: Lies sie aus constraints in /v1/models. Privatsphäre: auf /v1, über das TEE. Lade die Datei herunter, sobald sie fertig ist.

Stimme: vorlesen, transkribieren

Ziel: einen Absatz in eine MP3 verwandeln und eine Audiodatei zurück in Text.

Mit dem MCP-Server: „Lies diesen Absatz auf Französisch vor und speichere die MP3. Transkribiere sie dann zur Kontrolle.“ – carpe_tts, carpe_transcribe.

import os, requests
 
BASE = "https://carpe-diem.xyz/api/operator/v1"
H = {"Authorization": f"Bearer {os.environ['CARPE_API_KEY']}"}
 
speech = requests.post(f"{BASE}/audio/speech", headers=H, json={
    "model": "tts-kokoro", "input": "Bonjour ! Ceci est un test de synthèse vocale.", "response_format": "mp3",
})
speech.raise_for_status()
open("hello.mp3", "wb").write(speech.content)
 
text = requests.post(f"{BASE}/audio/transcriptions", headers=H,
    files={"file": ("hello.mp3", speech.content, "audio/mpeg")},
    data={"model": "openai/whisper-large-v3"}).json()
print(text["text"])

Kosten: 0,0003 $ für diesen Satz, beide Schritte zusammen (Sprachausgabe wird pro Zeichen abgerechnet, Transkription pro Minute Audio). Stimmen sind modellspezifisch: Lass voice für die Standardstimme weg oder wähle eine aus den voices des Modells in /v1/models. Privatsphäre: auf /v1, über das TEE. Das Klonen einer Stimme (carpe_voice_clone, POST /v1/audio/voices) erfordert die Einwilligung der sprechenden Person und wird vom Anbieter 7 Tage aufbewahrt.

Musik für ein Video

Ziel: ein Hintergrund-Track, passend zur Länge deines Clips.

Mit dem MCP-Server: „Komponiere einen ruhigen, 60 Sekunden langen Lo-Fi-Piano-Track, instrumental, und speichere ihn.“ – carpe_music_generate, carpe_music_status.

import os, time, requests
 
BASE = "https://carpe-diem.xyz/api/operator/v1"
H = {"Authorization": f"Bearer {os.environ['CARPE_API_KEY']}"}
 
qid = requests.post(f"{BASE}/audio/music/queue", headers=H, json={
    "model": "ace-step-15", "prompt": "calm lo-fi piano loop, warm, slow", "duration_seconds": 60,
}).json()["queue_id"]
 
while True:
    r = requests.post(f"{BASE}/audio/music/retrieve", headers=H, json={"queue_id": qid, "model": "ace-step-15"})
    if r.headers.get("content-type", "").startswith("audio/"):
        open("track.flac", "wb").write(r.content)  # ace-step-15 delivers FLAC; a /v1 track can be fetched once
        break
    if r.json().get("status") == "failed":
        raise RuntimeError(r.text)
    time.sleep(5)

Kosten: etwa 0,016 $ für 60 Sekunden mit ace-step-15. Jedes Musikmodell akzeptiert andere Längen, Optionen und Dateiformate (duration_options, supports_lyrics, default_format…): Lies vorher seine constraints in /v1/models. Privatsphäre: auf /v1, über das TEE.

Fragen zu deinen Dokumenten beantworten (RAG)

Ziel: ein kleiner Frage-Antwort-Bot über deine eigenen Notizen.

import os, math
from openai import OpenAI
 
client = OpenAI(base_url="https://carpe-diem.xyz/api/operator/v1", api_key=os.environ["CARPE_API_KEY"])
docs = [
    "Refunds are possible within 30 days of purchase.",
    "Support answers in English and French, Monday to Friday.",
    "Enterprise plans include a dedicated account manager.",
]
 
def embed(texts):
    r = client.embeddings.create(model="text-embedding-bge-m3", input=texts)
    return [d.embedding for d in r.data]
 
def cos(a, b):
    return sum(x * y for x, y in zip(a, b)) / (math.sqrt(sum(x * x for x in a)) * math.sqrt(sum(y * y for y in b)))
 
index = embed(docs)
question = "Can I get my money back after three weeks?"
q = embed([question])[0]
best = max(range(len(docs)), key=lambda i: cos(q, index[i]))
 
answer = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[
        {"role": "system", "content": f"Answer only from this context: {docs[best]}"},
        {"role": "user", "content": question},
    ],
)
print(answer.choices[0].message.content)

Kosten: 0,00015 $ für diese Frage, Embeddings inklusive; einen großen Dokumentbestand einmal zu embedden kostet einen Bruchteil eines Cents pro hundert Seiten. Privatsphäre: beide Aufrufe auf /v1, über das TEE; text-embedding-bge-m3 und deepseek-v4-flash sind private-Modelle. Dasselbe funktioniert mit LangChain oder LlamaIndex.

Web-Recherche mit Quellen

Ziel: eine kurze, belegte Antwort zu etwas Aktuellem.

Mit dem MCP-Server: „Such im Web nach dem neuesten Upgrade des Base-Netzwerks und fasse es mit Quellen zusammen.“ – carpe_web_search, carpe_web_scrape, dann carpe_chat.

import os, requests
from openai import OpenAI
 
BASE = "https://carpe-diem.xyz/api/operator/v1"
H = {"Authorization": f"Bearer {os.environ['CARPE_API_KEY']}"}
 
results = requests.post(f"{BASE}/augment/search", headers=H, json={"query": "Base network latest upgrade"}).json()["results"][:5]
context = "\n\n".join(f"[{i + 1}] {r['title']} ({r['url']})\n{r['content']}" for i, r in enumerate(results))
 
client = OpenAI(base_url=BASE, api_key=os.environ["CARPE_API_KEY"])
r = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[
        {"role": "system", "content": "Answer from the sources below and cite them as [n].\n\n" + context},
        {"role": "user", "content": "What changed in the latest Base network upgrade?"},
    ],
)
print(r.choices[0].message.content)

Um eine ganze Seite zu lesen, liefert POST /v1/augment/scrape mit {"url": "https://…"} ihren Inhalt. Kosten: 0,0054 $ pro Suche oder Scrape, plus die Antwort (insgesamt 0,0056 $ für diese hier). Privatsphäre: auf /v1, über das TEE; die Suche selbst geht ins Web.

Strukturierte Extraktion im großen Stil

Ziel: Tausende E-Mails, Rechnungen oder Tickets günstig in sauberes JSON verwandeln, ohne doppelte Abrechnung bei Wiederholungen.

import json, os, uuid
from openai import OpenAI
 
client = OpenAI(base_url="https://carpe-diem.xyz/api/operator/router", api_key=os.environ["CARPE_API_KEY"], max_retries=3)
schema = {
    "name": "invoice",
    "strict": True,
    "schema": {
        "type": "object",
        "properties": {
            "vendor": {"type": "string"},
            "total": {"type": "number"},
            "currency": {"type": "string"},
            "due_date": {"type": "string"},
        },
        "required": ["vendor", "total", "currency", "due_date"],
        "additionalProperties": False,
    },
}
 
def extract(text: str) -> dict:
    r = client.chat.completions.create(
        model="deepseek-v4-flash",
        messages=[{"role": "user", "content": f"Extract the invoice fields:\n\n{text}"}],
        response_format={"type": "json_schema", "json_schema": schema},
        # Same key on a retry → the router replays the first answer instead of billing twice.
        extra_headers={"Idempotency-Key": str(uuid.uuid5(uuid.NAMESPACE_URL, text))},
    )
    return json.loads(r.choices[0].message.content)
 
print(extract("ACME Corp — Invoice 1042 — Total due: 1,250.00 EUR by 2026-12-01."))

Kosten: 0,00004 $ für diese Rechnung über den Router. Privatsphäre: Der Router kann sie außerhalb des TEE bedienen: Füge extra_body={"privacy": "private"} für Märkte hinzu, die nichts speichern (die idempotente Wiedergabe ist dann deaktiviert), oder nutze /v1. Bleib unter den Rate Limits: Deine Werte liest du mit GET /v1/rate_limits.

Ausgaben unter Kontrolle halten

Ziel: wissen, wohin das Geld fließt, und sicherstellen, dass ein Agent nicht damit durchbrennen kann.

• Pro Key: Leg in API → Keys pro App oder Agent einen eigenen Key an, damit die Ausgaben jedes einzelnen getrennt sind (GET /buyer/api-keys/usage).
• Im MCP-Server: CARPE_MAX_PER_CALL_USD und CARPE_MAX_SPEND_USD lehnen einen Aufruf ab, bevor er gesendet wird; CARPE_READ_ONLY=1 für einen Assistenten, der nur nachschlagen soll.
• Berichte: Führe den Prompt cost_report aus oder frag „Wie viel habe ich diese Woche ausgegeben, für welche Modelle, und wie viel hat der Router gespart?“. Mit der API:

curl -s https://carpe-diem.xyz/api/operator/v1/credits -H "Authorization: Bearer $CARPE_API_KEY"
curl -s "https://carpe-diem.xyz/api/operator/buyer/usage/summary?days=7" -H "Authorization: Bearer $CARPE_API_KEY"
curl -s "https://carpe-diem.xyz/api/operator/buyer/routing/summary" -H "Authorization: Bearer $CARPE_API_KEY"

• Jede Antwort enthält ihre Kosten (X-Carpe-Cost-Usdc-Micro auf /v1, X-Carpe-Route-Cost-Usdc auf /router) und dein verbleibendes Guthaben (X-Carpe-Available-Credits), sodass eine App sich selbst stoppen kann.
• Wenn ein Key geleakt ist: Widerrufe ihn in API → Keys oder lass den Key sich selbst widerrufen: POST /v1/keys/self/revoke (das MCP-Tool carpe_revoke_this_key).

Ein Agent, der selbst bezahlt (x402)

Ziel: ein autonomer Agent mit eigener Wallet und hartem Budget – kein Konto, kein Key zu verwalten.

Lade eine dedizierte Wallet mit etwas USDC auf Base auf und gib ihren Private Key dann zusammen mit einem Budget an den MCP-Server:

{
  "mcpServers": {
    "carpe": {
      "command": "npx",
      "args": ["-y", "carpe-diem-mcp"],
      "env": {
        "CARPE_X402_PRIVATE_KEY": "0xYOUR_AGENT_WALLET_KEY",
        "CARPE_X402_BUDGET_USD": "2",
        "CARPE_MAX_PER_CALL_USD": "0.25"
      }
    }
  }
}

Der Server signiert ein einziges USDC-Permit, dessen Wert das Budget ist: Carpe kann insgesamt nie mehr als 2 $ einziehen, egal was der Agent tut, und die Ausgaben bleiben über Neustarts hinweg gespeichert. carpe_x402_status zeigt die Wallet, ihre USDC und was übrig ist. Wie du das aus deinem eigenen Code heraus machst, steht unter x402 in der API-Referenz.

Kosten: was der Agent verbraucht, zu denselben Preisen. Privatsphäre: kein Konto, keine E-Mail: Die Wallet ist die Identität.

Eine private Chat-App für ein Team

Ziel: eine ChatGPT-ähnliche App für dein Team, mit Modellen deiner Wahl, ohne dass jede Person irgendwo ein Konto braucht.

Deploye Open WebUI oder LibreChat mit einem Carpe-Key (oder mit LibreChats user_provided einem Key pro Nutzer). Richte sie auf https://carpe-diem.xyz/api/operator/v1 aus, damit jede Konversation über das TEE läuft, und lass für vertrauliche Arbeit nur private-Modelle sichtbar. Gib der App zusätzlich den MCP-Server (LibreChat), und alle können im selben Chat Bilder, Sprachausgabe und Web-Recherche anfordern.

Kosten: pro Nachricht, zum Preis von Carpe; verfolge sie pro Key in API → Usage. Privatsphäre: auf /v1, über das TEE; mit private-Modellen speichert der Modellanbieter nichts.