Zum Inhalt

Automationen und Code (integrierter MCP-Server „Automation“)

Der integrierte MCP-Server Automation erweitert Assistenten um zwei zentrale Fähigkeiten:

  • Automationen ausführen: wiederkehrende Abläufe zuverlässig nach Ereignissen oder Zeitplänen anstoßen.
  • Code-Tool: kleine TypeScript/JavaScript-Skripte sicher in einer isolierten Umgebung ausführen, um Daten zu verarbeiten oder Aktionen zu orchestrieren.

Diese Seite erklärt, was du damit als Endnutzer tun kannst, und welche Funktionen dir im Code-Tool zur Verfügung stehen.

Wann ist der Automation-Server sinnvoll?

Nutze ihn, wenn du:

  • Daten aus Dateien/Ergebnissen transformieren willst (z. B. Liste bereinigen, Felder normieren, JSON erzeugen).
  • Tools kombinieren willst (z. B. erst suchen, dann Ergebnisse filtern, dann als Datei speichern).
  • aus einem Trigger heraus Folgeschritte durchführen willst (z. B. „Wenn X passiert, lege Einträge an, schreibe eine Zusammenfassung, speichere Artefakte“).

Wenn du nur eine normale Frage beantwortet haben willst, ist der Automation-Server meist nicht nötig.

Das Code-Tool (JS/TS im Chat ausführen)

Das Code-Tool führt TypeScript/JavaScript in einer Sandbox aus:

  • keine Shell-Befehle, kein direkter Systemzugriff
  • Zugriff auf ein virtuelles Dateisystem (für Inputs/Outputs)
  • Zugriff auf MCP-Tools (wenn verbunden/erlaubt)
  • Hilfsfunktionen für Events und Wissens-/Chunk-Operationen

Zwei Modi: Chat vs. Automation (wichtig)

Je nachdem, wo du Code ausführst, gelten unterschiedliche Regeln:

  • Im Chat (interaktiver Lauf)
  • Dateien liegen im Chat-Kontext (Uploads + Workspace).
  • HTTP/fetch ist bewusst deaktiviert (damit kein unkontrollierter Netzwerkzugriff im Chat passiert).
  • In einer Automation (hintergrund)
  • Der Lauf ist auf die Automation bezogen.
  • HTTP/fetch ist möglich, wenn eure Umgebung das zulässt.

Dateisystem (fs)

Im Code steht dir ein fs-Objekt zur Verfügung.

Chat-Kontext (typische Ordner)

Im Chat arbeitest du in einem Root wie:

  • /chats/<chatId>/assets (Uploads, nur lesen)
  • /chats/<chatId>/workspace (dein Arbeitsbereich, schreiben erlaubt)
  • /chats/<chatId>/workspace/out (Outputs)
  • /chats/<chatId>/workspace/tmp (temporär)
  • /chats/<chatId>/.tool-results (Tool-Artefakte)

Wichtig: Das aktuelle Arbeitsverzeichnis startet bereits in .../workspace. Nutze deshalb bevorzugt relative Pfade wie out/result.json statt workspace/out/result.json.

Verfügbare fs-Funktionen

  • fs.pwd() – aktuelles Verzeichnis
  • await fs.cd(path) – Verzeichnis wechseln
  • await fs.ls(dir?, { glob?, limit?, offset?, withStat? }) – Dateien/Ordner listen
  • await fs.exists(path)
  • await fs.mkdir(path, { recursive? })
  • await fs.rm(path, { recursive? })
  • await fs.readText(path, { maxBytes? })
  • await fs.writeText(path, content)
  • await fs.readJson(path)
  • await fs.writeJson(path, value, { pretty? })
  • await fs.mv(src, dst, { overwrite? })
  • await fs.cp(src, dst, { recursive?, overwrite? })

MCP-Tools nutzen (mcp)

Wenn in eurem Space MCP-Server verbunden sind, kannst du sie aus dem Code heraus verwenden:

  • await mcp.tools() listet verfügbare Tools (Name + Beschreibung).
  • await mcp.call("serverName/toolName", { ...args }) ruft ein Tool auf.

So kannst du z. B. „Suche → Filter → Export“ automatisieren, ohne alles manuell zu klicken.

Events abfragen (lastEvent, getEvents)

Für Automationen ist es oft wichtig, Ereignisse nachzuschlagen:

  • await lastEvent({ type?, objectId?, causedBy? }) – gibt das letzte passende Event zurück (oder null)
  • await getEvents({ type?, objectId?, causedBy?, limit?, cursor?, direction? }) – paginierte Liste

Das ist praktisch, um z. B. „Was ist zuletzt passiert?“ in einer Automation zu prüfen.

Wissen/Chunks bearbeiten (addChunks, deleteChunk, deleteChunks)

Du kannst Inhalte als Chunks in den Space schreiben oder entfernen:

  • await addChunks([{ id, text?, url?, metadata?, addedAutomatically? }, ...])
  • await deleteChunk(chunkId)
  • await deleteChunks([chunkId1, chunkId2, ...])

Typische Nutzung:

  • Ergebnisse als neue Wissenskarte/Chunk ablegen
  • veraltete automatische Chunks aufräumen

Tools direkt aufrufen (tools.NAME)

Im Code gibt es ein tools-Objekt. Jedes verfügbare Tool kann wie eine Funktion aufgerufen werden, z. B.:

const res = await tools.rag_search({ query: "NDA", filter: undefined });

Welche Tool-Namen bei euch verfügbar sind, hängt von eurem Setup (Assistent/Space) ab.

dispatchEvent (fortgeschritten)

In manchen Setups kann ein Skript auch Events auslösen. Dafür steht ein Modul clye.ai zur Verfügung. Wenn ihr das nutzt, macht das am besten nur in klar definierten Automationen.

Beispiele

Beispiel: Upload lesen und Ergebnis als JSON speichern (Chat)

export default async function () {
  const input = await fs.readText("assets/input.txt");
  const lines = input.split("\n").map((l) => l.trim()).filter(Boolean);
  await fs.writeJson("out/result.json", { count: lines.length, lines });
  return { ok: true };
}

Beispiel: Tools kombinieren (Suche → Ergebnis speichern)

export default async function () {
  const result = await tools.rag_search({ query: "Vertrag", filter: undefined });
  await fs.writeJson("out/rag-result.json", result, { pretty: true });
  return { saved: true, items: result?.chunks?.length ?? 0 };
}

Kurz gesagt

Der integrierte MCP-Server Automation ist der richtige Baustein, wenn ihr über reine Chat-Antworten hinaus wollt: wiederholbar, nachvollziehbar, mit Outputs, und mit der Möglichkeit, Tools und Datenverarbeitung in einem sicheren Code-Lauf zu kombinieren.