AI Ask API
Die AI Ask API nimmt eine Frage in einfacher Sprache, lässt den konfigurierten LLM-Provider eine typisierte Abfrage gegen das lebende Cube-Schema ausfüllen, schickt diese Abfrage durch denselben Konverter, den die typisierte AI Query API verwendet, und gibt das ausgeführte Ergebnis + das erzeugte MDX + die strukturierte Anfrage zurück, die das Modell emittiert hat.
Es ist die Natural-Language-Schicht, die auf der typisierten
Agenten-Oberfläche sitzt. Wo die typisierte API davon ausgeht, dass der
Aufrufer AiQueryRequest spricht, lässt die Ask-API einen Menschen
„zeig mir den Umsatz nach Land im letzten Quartal” sagen und liefert
einen vollständig ausgeführten Cellset zurück, mit der Übersetzung des
Modells daneben sichtbar.
Das treibt das AI-Query-Drawer im Workspace an — die ⚡-Schaltfläche in der Symbolleiste öffnet ein Chat-Panel, in dem Benutzer Fragen tippen und auf In Canvas bearbeiten klicken, um das Ergebnis in den aktiven Abfrage-Tab zu legen.
Wann ist sie zu verwenden?
Die Ask-API ist die richtige Oberfläche, wenn:
- Endbenutzer Fragen tippen werden — die typisierte AI Query API erwartet einen Agenten, der das Cube-Schema bereits kennt; die Ask-API verbirgt diesen Schritt hinter einem LLM.
- Sie einen Round-Trip pro Frage wollen —
/ai/askerledigt Übersetzung + Ausführung + Envelope-Formung in einem einzigen Aufruf, sodass der Client nicht zwei APIs verketten muss. - Sie eine Chat-artige Oberfläche einbetten — das mehrstufige
history-Feld lässt Folgefragen gegen frühere Runden auflösen.
Wann sie nicht zu verwenden ist:
- Agenten auf dem MCP-Server — Agenten bevorzugen die typisierte Oberfläche, weil sie ohnehin gut darin sind, strukturierte Felder aus einem JSON Schema zu füllen. Die Ask-Schicht ist für Menschen.
- Cubes aus einem Beispiel-Warehouse verfassen — nutzen Sie die AI Inference API, die für den Design-Time-Fluss gedacht ist.
Aktivierung
Zwei Properties + eine Env-Variable pro Provider. Beides lässt sich auf der JVM setzen oder in der Properties-Datei des Deployments, die Spring liest.
# Anthropic Claudesaiku.ai.ask.provider = anthropic# env ANTHROPIC_API_KEY = sk-ant-...
# OpenAI — or any OpenAI-compatible host (vLLM, Ollama, Together, LiteLLM)saiku.ai.ask.provider = openai# env OPENAI_API_KEY = sk-...
# Azure OpenAI Service (saiku#1431). See BYOLLM below.saiku.ai.ask.provider = azure-openaisaiku.ai.ask.endpoint = https://<resource>.openai.azure.com/openai/deployments/<deployment>/chat/completions?api-version=2024-02-15-previewsaiku.ai.ask.model = <deployment># env AZURE_OPENAI_API_KEY = <azure-key>
# Optional, all providerssaiku.ai.ask.model = claude-sonnet-4-6 | gpt-4o-mini | ...saiku.ai.ask.endpoint = https://my.openai-compatible.host/v1/chat/completionssaiku.ai.ask.apiKey = ... # explicit override of the env varsaiku.ai.ask.timeoutSeconds = 60 # or env SAIKU_AI_ASK_TIMEOUT_SECONDSProvider-Defaults:
| Provider | Default-Modell | Endpunkt |
|---|---|---|
anthropic | claude-sonnet-4-6 | https://api.anthropic.com/v1/messages |
openai | gpt-4o-mini | https://api.openai.com/v1/chat/completions |
azure-openai | (kein Default) | (kein Default — verweigert die Konstruktion ohne explizite Deployment-URL) |
Docker
docker run -d --name saiku \ -e ANTHROPIC_API_KEY=sk-ant-... \ -e JAVA_OPTS='-Dsaiku.ai.ask.provider=anthropic' \ ghcr.io/spiculedata/saiku:latestKubernetes
Nutzen Sie ein Secret für den Key, eine ConfigMap für den
Provider-Namen:
apiVersion: v1kind: Secretmetadata: name: saiku-aitype: OpaquestringData: ANTHROPIC_API_KEY: sk-ant-...---apiVersion: apps/v1kind: Deploymentmetadata: name: saikuspec: template: spec: containers: - name: saiku envFrom: - secretRef: name: saiku-ai env: - name: JAVA_OPTS value: -Dsaiku.ai.ask.provider=anthropicBYOLLM — bringen Sie Ihr eigenes Modell mit (saiku#1431)
Enterprise-Deployments können Prompts oft nicht direkt an Anthropic oder OpenAI schicken — das LLM muss innerhalb der VPC des Kunden oder hinter dessen bestehendem Einkauf laufen. Die Ask-Schicht deckt die drei häufigsten BYOLLM-Formen ab, ohne schwere Abhängigkeiten in Saiku zu backen.
| Form | Provider | Endpunkt-Format | Auth-Header |
|---|---|---|---|
| Azure OpenAI Service | azure-openai | https://<resource>.openai.azure.com/openai/deployments/<deployment>/chat/completions?api-version=<v> | api-key: <key> |
| Self-hosted / OpenAI-kompatibler Proxy (vLLM, Ollama, LiteLLM, Together, Groq) | openai | jede URL, die OpenAIs Chat-Completions-API spricht | Authorization: Bearer <key> |
| AWS Bedrock über LiteLLM davor | openai | LiteLLM vor Bedrock (https://litellm.internal/v1/chat/completions) | Authorization: Bearer <litellm-key> |
Der native azure-openai-Adapter kümmert sich um die beiden
Azure-spezifischen Dinge (Deployment-Name in der URL und
api-key-Header), sodass Operatoren für den häufigsten Fall keinen
Übersetzungs-Proxy betreiben müssen.
Azure-OpenAI-Aktivierung
-
Deployen Sie ein OpenAI-kompatibles Modell in Ihre Azure-OpenAI-Ressource. Notieren Sie Ressourcen- und Deployment-Namen.
-
Holen Sie einen Key aus dem Azure Portal → Ihre Ressource → Keys and Endpoint.
-
Setzen Sie auf dem Launcher:
saiku.ai.ask.provider = azure-openaisaiku.ai.ask.endpoint = https://my-resource.openai.azure.com/openai/deployments/my-deployment/chat/completions?api-version=2024-02-15-previewsaiku.ai.ask.model = my-deployment# env AZURE_OPENAI_API_KEY = <azure-api-key> -
Booten Sie den Launcher. Eine INFO-Zeile beim Start bestätigt die Verdrahtung:
INFO o.s.s.o.a.a.NlAskProviderFactory - AI ask provider: azure-openai (deployment/model=my-deployment, endpoint=https://…)
AWS Bedrock über LiteLLM
Das empfohlene Muster für Bedrock ist,
LiteLLM als OpenAI-kompatible Front zu
betreiben und Saikus vorhandenen openai-Provider auf LiteLLM zu
richten. LiteLLM erledigt die SigV4-Signierung stromaufwärts, sodass
Saiku das AWS SDK nicht im Classpath braucht.
model_list: - model_name: claude-sonnet-3-5 litellm_params: model: bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0 aws_region_name: us-east-1
litellm_settings: drop_params: truelitellm --config litellm-config.yaml --port 4000Und dann auf der Saiku-Seite:
saiku.ai.ask.provider = openaisaiku.ai.ask.endpoint = http://litellm.internal:4000/v1/chat/completionssaiku.ai.ask.model = claude-sonnet-3-5# env OPENAI_API_KEY = <any-value-litellm-passes-through>Derselbe Trick funktioniert für jedes Bedrock-Modell (Titan, Cohere, Mistral, Llama) sowie für GCP Vertex AI, Databricks Model Serving und jeden anderen Provider, den LiteLLM abdeckt.
Selbst gehostete Modelle
Jeder Host, der OpenAIs Chat-Completions-API spricht, ist ein Drop-in-Ersatz. Die gängigen:
- vLLM — selbst gehostete GPU-Inferenz; OpenAI-kompatibel ab Werk.
- Ollama — lokale Entwicklung; aktivieren Sie den
OpenAI-Kompatibilitätsadapter mit
OLLAMA_HOST=0.0.0.0. - Together und Groq — SaaS-OpenAI-kompatible Endpunkte für Self-Service-Modell-Hosting.
- LiteLLM — Proxy, der alles (Bedrock, Vertex, Azure, Anthropic, Hunderte weitere) als OpenAI-kompatibel vorblendet.
saiku.ai.ask.provider = openaisaiku.ai.ask.endpoint = https://my.vllm.internal/v1/chat/completionssaiku.ai.ask.model = mistralai/Mistral-7B-Instruct-v0.3# env OPENAI_API_KEY = <any-value-your-server-accepts>Der Endpunkt
POST /saiku/api/ai/askAnfrage
{ "question": "show sales by country last quarter", "cube": { "connectionName": "foodmart", "catalog": "FoodMart", "schema": "FoodMart", "cubeName": "Sales" }, "history": [ { "role": "user", "content": "earlier question" }, { "role": "assistant", "content": "earlier summary" } ], "cellsetDigest": "| Country | Store Sales |\n|---|---|\n| USA | 565,238.13 |", "forceTool": "query"}Nur question und cube sind erforderlich.
history — frühere (user, assistant)-Runden, die an das Modell
zurückgesendet werden, sodass Folgefragen wie „jetzt nach Region
aufschlüsseln” gegen die frühere Frage aufgelöst werden. System-Prompts
werden vom Server kontrolliert; Aufrufer können sie nicht einschleusen.
cellsetDigest — ein Markdown-Digest des Ergebnisses, das der
Benutzer gerade ansieht. Dieses Feld zählt mehr, als es aussieht:
forceTool — die Runde auf eine Intent festnageln, statt das Modell
wählen zu lassen. query, insight, view_change oder dashboard;
lassen Sie es weg (oder senden auto), damit das Modell routet. Das
Workspace-Drawer bietet das als Auswahl Auto / Query / Insight / View an.
dashboard ist die Ausnahme: Es ist nie Teil von auto und nur
erreichbar, wenn man es ausdrücklich anfordert.
Antwort
Die Antwort trägt bei Erfolg genau eine Intent. Welche, hängt davon
ab, wie das Modell die Runde geroutet hat — verzweigen Sie also auf
Anwesenheit und nehmen Sie nicht an, dass request immer da ist:
| Feld | Vorhanden, wenn | Enthält |
|---|---|---|
request + response + queryModel | Das Modell mit einer Query geantwortet hat | Die typisierte Anfrage, das ausgeführte Ergebnis und das strukturierte Query-Modell |
insight | Das Modell mit einer Insight geantwortet hat | Markdown-Analyse des Cellsets, den Sie gesendet haben |
viewChange | Das Modell mit einem View Change geantwortet hat | Ein Ziel-View-Modus + Diagrammtyp |
emailDraft | Das Modell eine E-Mail verfasst hat — und Mail konfiguriert ist | Ein Entwurfstext. Nur Entwurf; das Senden läuft über den normalen E-Mail-Endpunkt, nie über diesen |
Dazu bei jeder Antwort: degraded, model und reason, wenn etwas
schiefging.
{ "degraded": false, "model": "claude-sonnet-4-6", "request": { /* the structured AiQueryRequest the model emitted */ }, "response": { /* the full AiQueryResponse — same shape as /ai/query */ }, "queryModel": { /* the ThinQueryModel, for hydrating a visual builder */ }, "generatedMdx": "SELECT NON EMPTY ... FROM [Sales]"}request ist die strukturierte Abfrage, die das Modell erzeugt hat.
Übergeben Sie sie wortwörtlich an POST /ai/query,
um sie erneut auszuführen, oder zeigen Sie sie dem Benutzer als „die
typisierte Abfrage hinter Ihrer Frage” an.
response ist das ausgeführte Ergebnis, gleiche Form wie die typisierte
AI Query API zurückgibt. Wenn das Modell eine Anfrage erzeugt hat, die
das Schema ablehnt, ist response.status gleich VALIDATION_ERROR und
der Body enthält field + available-Kandidaten — das Workspace-Drawer
rendert diese als anklickbare Chips, damit der Benutzer selbst
korrigieren kann.
queryModel ist dasselbe strukturierte Modell, das die Chips der
Werkbank manipulieren. Es ist das, was In Canvas bearbeiten eine
Abfrage zurückgeben lässt, an der der Benutzer weiterziehen kann, statt
einer Wand aus MDX, an der er es nicht kann. Fehlt auf degraded Pfaden
und dort, wo die Konvertierung scheiterte, bevor eines entstand.
generatedMdx ist ein bequemer Spiegel von
response.metadata.generatedMdx.
Statuscodes
| HTTP | Wann |
|---|---|
200 | Übersetzung erfolgreich; response enthält das ausgeführte Ergebnis (oder VALIDATION_ERROR zur Selbstkorrektur). |
200 + degraded:true | Übersetzung in der Provider-Schicht fehlgeschlagen — Transportfehler, Modell hat abgelehnt oder Parse-Fehler. reason enthält die Erklärung. |
400 | Fehlendes question oder cube im Body. |
503 + degraded:true | Provider ist noop (nicht konfiguriert) — reason erklärt, wie aktiviert wird. |
Beispiele
Standardmäßig aus — klare Rückmeldung
curl -sS -X POST -H 'Content-Type: application/json' \ -u admin:admin \ http://localhost:8080/saiku/api/ai/ask \ -d '{"question":"show sales by country","cube":{"connectionName":"foodmart","catalog":"FoodMart","schema":"FoodMart","cubeName":"Sales"}}'
# {# "degraded": true,# "reason": "AI ask is not configured. Set saiku.ai.ask.provider..."# }Happy Path — vollständiger Round-Trip
curl -sS -X POST -H 'Content-Type: application/json' \ -u admin:admin \ http://localhost:8080/saiku/api/ai/ask \ -d '{"question":"show sales by country","cube":{"connectionName":"foodmart","catalog":"FoodMart","schema":"FoodMart","cubeName":"Sales"}}' \ | jq '{model, generatedMdx, rows: .response.totalRows}'
# {# "model": "claude-sonnet-4-6",# "generatedMdx": "SELECT NON EMPTY {[Measures].[Store Sales]} ON COLUMNS, NON EMPTY {[Customers].[Country].Members} ON ROWS FROM [Sales]",# "rows": 3# }Folgefrage — mehrstufig
curl -sS -X POST -H 'Content-Type: application/json' \ -u admin:admin \ http://localhost:8080/saiku/api/ai/ask \ -d @- <<'EOF'{ "question": "now break it down by quarter", "cube": {"connectionName":"foodmart","catalog":"FoodMart","schema":"FoodMart","cubeName":"Sales"}, "history": [ {"role":"user","content":"show sales by country"}, {"role":"assistant","content":"3 rows returned."} ]}EOFDas Modell sieht die vorherige Runde und löst „nach Quartal” so auf, dass es auch gegen Land gekreuzt wird — gleiche Form wie die erste Antwort mit einer zusätzlichen Hierarchie.
Streaming-Variante — POST /ai/ask/stream (saiku#1433)
Begleitender Endpunkt, der Server-Sent Events spricht, damit eingebettete Chat-Oberflächen Fortschritt rendern können, während er eintrifft, statt auf den vollen Round-Trip zu blockieren. Gleicher Request-Body, gleiche Auth, gleiche Rate-Limits, gleiche Envelope-Form — die Antwort ist ein Strom typisierter Events statt eines einzelnen JSON-Blobs.
Event-Schema
event: modeldata: {"model":"claude-sonnet-4-6"}
event: intentdata: {"kind":"INSIGHT"}
event: chunkdata: {"delta":"Store "}
event: chunkdata: {"delta":"Sales trended up 12% week-on-week."}
event: finaldata: {"degraded":false,"model":"claude-sonnet-4-6","insight":{"markdown":"Store Sales trended up 12% week-on-week."}}| Event | Wann | Payload |
|---|---|---|
model | Feuert immer zuerst, wenn der Provider eine Modell-ID zurückgab | {"model": "<id>"} |
intent | Nach dem Tool-Routing, vor dem Payload | {"kind": "QUERY" | "INSIGHT" | "VIEW_CHANGE"} |
chunk | Null- oder mehrmals bei prosatragenden Intents (INSIGHT, VIEW_CHANGE.reason) | {"delta": "<Chunk an Wortgrenze>"} — Deltas zu verketten ist verlustfrei |
final | Feuert bei Erfolg immer zuletzt | Vollständiger AskResponse-Envelope — gleiche Form wie synchrones /ai/ask |
error | Transport-/Parse-/Auth-Fehler des Providers | {"reason": "<Erklärung>"} — gefolgt von einem final mit degraded:true |
Client-Beispiele
EventSource kann nur GET, POST-Bodies laufen also über fetch +
manuelles Event-Parsing:
const res = await fetch('/rest/saiku/api/ai/ask/stream', { method: 'POST', headers: { 'content-type': 'application/json', accept: 'text/event-stream', }, credentials: 'include', body: JSON.stringify({ question, cube }),});
const reader = res.body!.getReader();const decoder = new TextDecoder();let buffer = '';let markdown = '';
while (true) { const { done, value } = await reader.read(); if (done) break; buffer += decoder.decode(value, { stream: true }); // Events are separated by a blank line (double-newline). const events = buffer.split('\n\n'); buffer = events.pop() ?? ''; for (const raw of events) { const evt = parseSseEvent(raw); if (evt.event === 'chunk') { markdown += JSON.parse(evt.data).delta; render(markdown); } else if (evt.event === 'final') { const full = JSON.parse(evt.data); renderFinal(full); } else if (evt.event === 'error') { showError(JSON.parse(evt.data).reason); } }}
function parseSseEvent(raw: string) { let event = 'message', data = ''; for (const line of raw.split('\n')) { if (line.startsWith('event: ')) event = line.slice(7); else if (line.startsWith('data: ')) data += (data ? '\n' : '') + line.slice(6); } return { event, data };}Jeder SSE-Client funktioniert — dieser Endpunkt liefert einen Strom
typisierter Events, nicht die Vercel-geprägten Chunks, die das AI SDK
nativ erwartet. Sie würden also einen kleinen Adapter schreiben, der
unsere chunk-Events in das übersetzt, was Ihre Rendering-Schicht
konsumiert.
async function* saikuAskStream(body: unknown) { const res = await fetch('/rest/saiku/api/ai/ask/stream', { method: 'POST', headers: { 'content-type': 'application/json', accept: 'text/event-stream' }, credentials: 'include', body: JSON.stringify(body), }); // Yield each delta as the caller consumes them. for await (const evt of parseSseStream(res.body!)) { if (evt.event === 'chunk') yield JSON.parse(evt.data).delta as string; }}Praktisch zum lokalen Debuggen:
curl -N -X POST -u admin:admin \ -H 'content-type: application/json' \ -H 'accept: text/event-stream' \ http://localhost:8080/rest/saiku/api/ai/ask/stream \ -d '{"question":"what is trending?","cube":{...}}'Das -N schaltet curls Pufferung ab, damit Events beim Eintreffen
durchgereicht werden.
Nginx / Reverse Proxy
Setzen Sie X-Accel-Buffering: no (Saiku sendet das bereits) und
deaktivieren Sie die Proxy-Pufferung auf Ihrem Reverse Proxy, damit
Events Ende zu Ende durchgereicht werden:
location /rest/saiku/api/ai/ask/stream { proxy_pass http://saiku:8080; proxy_buffering off; proxy_set_header Connection ''; proxy_http_version 1.1; chunked_transfer_encoding off;}Was das Modell sieht vs. nicht sieht
Die Ask-Schicht sendet dem Modell nur:
- Das
AiSchemades aktiven Cubes — serialisiertes JSON der Measures, Dimensionen, Hierarchien, Levels und Sample-Member. - Das JSON Schema von
AiQueryRequestalsinput_schemades Structured-Output-Tools. - Die Frage des Benutzers und etwaige Konversationshistorie, die der Aufrufer angehängt hat.
Das Modell wird über tool_choice gezwungen, das emit_query-Tool mit
einer gültigen AiQueryRequest-Form aufzurufen. Rohe Prosa-Antworten
werden als degraded abgelehnt.
Es sieht niemals:
- Andere Cubes, auf die der Benutzer zugreifen kann — nur den in der Anfrage genannten.
- Das zugrundeliegende SQL oder die Warehouse-Anmeldedaten.
- Konversationshistorien anderer Benutzer.
- Die HTTP-Anfrage, Session-Cookies oder irgendeinen Header, den der Aufrufer gesendet hat.
Dies ist dasselbe Isolationsmodell, das der MCP-Server und die typisierte AI Query API verwenden, nur eine Schicht früher angewendet.
Begleitende Endpunkte
Der Ask-Endpunkt steht neben ein paar typisierten Helfern auf derselben
/rest/saiku/api/ai/*-Oberfläche. Agenten nutzen sie, um Namen
aufzulösen, bevor sie fragen, eine Simulation zu fahren oder einem
Operator beim Absichern der Governance zu helfen.
GET /ai/members/search — einen Member-Namen auflösen
Bevor Sie einen Member in einer Abfrage oder einem Filter referenzieren, schlagen Sie seinen exakten Unique Name mit einer Groß-/Kleinschreibung-ignorierenden Teilstring-Suche nach. Spiegelt die Werte-Suche auf der OSSIE-Seite.
| Query-Parameter | Pflicht | Anmerkungen |
|---|---|---|
cubeId | ja | connection/catalog/schema/cube |
dimension | ja | Dimensionsname |
hierarchy | nein | Hierarchiename (Default ist die Default-Hierarchie der Dimension) |
level | ja | Level, in dem gesucht wird |
q | nein | Suchstring; weglassen, um die ersten Member zu blättern |
limit | nein | Max. Treffer (Default 20) |
curl -sS -u admin:admin \ 'http://localhost:8080/saiku/api/ai/members/search?cubeId=foodmart/FoodMart/FoodMart/Sales&dimension=Product&level=Product%20Family&q=drink&limit=10'# → [ { "uniqueName": "[Product].[Drink]", "caption": "Drink", ... }, … ]POST /ai/scenario/whatif — Write-back-Simulation
Setzen Sie die Measure eines Members auf einen Zielwert, führen Sie die
Abfrage in einem frischen Mondrian-Szenario erneut aus und erhalten Sie
Ist vs. Was-wäre-wenn für jedes Geschwister und jede Summe, während
die Engine das Delta neu verteilt. Der Cube muss
enableScenarios="true" deklarieren.
curl -sS -X POST -H 'Content-Type: application/json' \ -u admin:admin \ http://localhost:8080/saiku/api/ai/scenario/whatif \ -d '{ "connection": "foodmart", "cube": "Sales", "level": "[Product].[Product Family]", "measure": "Store Sales", "member": "[Product].[Drink]", "value": 50000, "policy": "EQUAL_ALLOCATION" }'level und member sind MDX-Unique-Names; value ist der neue
absolute Measure-Wert für member; policy ist standardmäßig
EQUAL_ALLOCATION.
GET /ai/schema/{cubeId}/pii-suggestions — Governance-Helfer
Nur für Admins. Scannt den beschriebenen Cube nach Spalten, die einem
PII-Muster entsprechen, aber noch nicht mit pii=true annotiert sind,
damit ein Operator die PII-Redaction absichern kann,
ohne Logs zu greppen. Bewusst getrennt von der agentenseitigen
Schema-Sicht — Agenten sehen nie den Policy-Entwurf des Operators. Gibt
für einen noch nicht beschriebenen Cube eine leere Liste zurück (kein
404).
curl -sS -u admin:admin \ http://localhost:8080/saiku/api/ai/schema/foodmart/FoodMart/FoodMart/Sales/pii-suggestions# → { "suggestions": [ { "field": "customer_email", "reason": "matches email pattern" }, … ] }Skills — vom Admin verfasste Workflows
Skills sind Markdown-Dateien mit YAML-Frontmatter unter
saiku-home/skills/, die jede /ai/ask-Runde per Namen
(/weekly-rollup for Q4) oder per Natural-Language-Treffer aufrufen
kann. Vollständige Referenz in Agent Skills.
Agent Spaces — persona-gescopte Asks
Spaces sind benannte, vom Admin verfasste Personas („Sales Analyst”,
„Finance Ops”), die eine ganze Ask-Oberfläche scopen — System-Prompt,
Cube-Allowlist, Skill-Allowlist, Vorschlags-Prompts. POST /ai/spaces/{id}/ask nutzt denselben Envelope wie dieser Endpunkt, mit
serverseitiger Scope-Durchsetzung obendrauf. Vollständige Referenz in
Agent Spaces.
Wie geht es weiter?
- Agent Skills — vom Admin verfasste
Markdown-Workflows, die aus jeder
/ai/ask-Runde auffindbar sind. - Agent Spaces — Personas, die die Cube-Allowlist festnageln, den Skill-Katalog filtern und einen System-Prompt injizieren.
- Agent-Evals — YAML-Ground-Truth-Harness, um AI-Ask-Regressionen zu fangen, wenn sich LLM-Provider, Modell oder Prompt ändern.
- AI Query API — die typisierte Oberfläche, in die
/ai/askübersetzt. Nützlich, wenn ein Agent (kein Mensch) die Anfrage erstellen soll. - MCP-Server — dieselbe typisierte Oberfläche als MCP-Tools für Claude Desktop / Cursor / Cline Agenten.
- Authentifizierung — Bearer-Tokens, Rate-Limits, Fehlerformate.