Integrierte MCP-Server

Integrierte MCP-Server sind eingebaute Fähigkeiten des CLYE AI. Sie verhalten sich für Assistenten ähnlich wie angebundene MCP-Server, kommen aber direkt aus dem Produkt und brauchen oft keine externe Verbindung.

Ein integrierter MCP-Server erweitert, was ein Assistent tun kann oder wie er Informationen darstellt.

Wo du sie findest

Je nach Bereich findest du diese Fähigkeiten meist in den Einstellungen eines Assistenten unter MCP-Server, Werkzeuge, Integrationen oder einem ähnlichen Punkt.

Ob du sie sehen oder anpassen kannst, hängt von drei Dingen ab:

• deinem Kontext, also persönlicher Bereich oder gemeinsamer Bereich
• deiner Rolle
• eurer Freischaltung im Setup

Wann ein integrierter MCP-Server sinnvoll ist

Aktiviere solche Fähigkeiten nur dann, wenn sie im Alltag einen klaren Nutzen haben. Gute Gründe sind:

• ein Assistent soll Antworten anders darstellen
• ein Assistent soll gezielter auf Wissen zugreifen
• ein Assistent soll sich Dinge dauerhaft merken
• ein Assistent soll aktuelle Web-Inhalte einbeziehen

Wenn ein normaler Chat mit guter Frage und passender Ablage schon reicht, brauchst du meist keinen zusätzlichen integrierten MCP-Server.

Wie du sie im Alltag sinnvoll auswählst

Eine einfache Denkweise hilft:

• Darstellung: Wie soll die Antwort aussehen?
• Wissen: Worauf soll der Assistent zugreifen?
• Dauerhaftigkeit: Was soll er sich über Sitzungen hinweg merken?
• Aktualität: Braucht er Informationen aus dem Web?

Typische integrierte MCP-Server

• MDX im Chat für interaktive Antworten mit Karten, Tabs, Formularen oder Diagrammen
• Ablage-Suche (RAG) für Wissen aus Ablagen, Spaces und gepflegten Inhalten
• Memory für dauerhafte Notizen, Präferenzen und stabilen Kontext
• Web und Browser für aktuelle Informationen und gezieltes Öffnen von Webseiten
• Automationen und Code für wiederkehrende Abläufe und sichere JS/TS-Ausführung mit Dateien, Tools und Event-Logik

Für einen vollständigen, technischeren Überblick über alle eingebauten Server inklusive ihrer Eignung als Automation Action siehe:

• Katalog der integrierten MCP-Server

Gute Einführungsreihenfolge

1. Starte mit Ablage-Suche (RAG), wenn Wissen aus dem CLYE AI genutzt werden soll.
2. Ergänze Memory, wenn sich ein Assistent Dinge dauerhaft merken soll.
3. Nutze MDX im Chat, wenn Antworten visuell oder interaktiv werden sollen.
4. Schalte Web und Browser dazu, wenn aktuelle Informationen wirklich nötig sind.
5. Nutze Automationen und Code, wenn ihr wiederkehrende Abläufe sauber automatisieren oder Tool-Ketten zuverlässig ausführen wollt.

Was du vermeiden solltest

• aktiviere nicht alles auf einmal
• verwechsel gute Darstellung nicht mit fachlich gutem Inhalt
• erwarte von Web-Funktionen keine Freigabe für ungeprüfte Aussagen
• lagere dauerhaftes Wissen nicht allein in Chats aus, wenn es in eine Ablage gehört

Kurz gesagt

Integrierte MCP-Server sind eingebaute Zusatzfähigkeiten für Assistenten. Sie sind dann wertvoll, wenn sie eine konkrete Lücke schließen: bessere Darstellung, besseres Auffinden von Wissen, dauerhaftes Merken oder aktueller Web-Zugriff.

---

MDX im Chat

MDX im Chat erlaubt es einem Assistenten, Antworten nicht nur als Fließtext, sondern als strukturierte Oberfläche im Chat darzustellen. Dazu gehören zum Beispiel Karten, Tabs, Accordions, Formulare oder einfache Diagramme.

Wofür MDX im Chat gut ist

Dieser integrierte MCP-Server ist besonders nützlich, wenn Antworten übersichtlicher oder interaktiver werden sollen.

Typische Fälle:

• strukturierte Zusammenfassungen
• Vergleichsansichten mit Karten oder Tabs
• kleine Formulare für Rückfragen
• Diagramme für Zahlen, Trends oder Verteilungen
• klar gegliederte Handlungsoptionen

Wann du ihn einschalten solltest

MDX lohnt sich vor allem dann, wenn der Assistent nicht nur antworten, sondern Ergebnisse besser präsentieren soll.

Das ist besonders hilfreich, wenn:

• mehrere Informationsblöcke gleichzeitig verständlich bleiben sollen
• Nutzer schnell zwischen Ansichten wechseln sollen
• Zahlen nicht nur als Tabelle, sondern als Grafik gezeigt werden sollen
• Rückfragen direkt über ein Formular gesammelt werden sollen

Wann normaler Text oft besser ist

Nicht jede Antwort braucht eine Oberfläche.

Gewöhnlicher Chat-Text reicht meist aus, wenn:

• die Antwort kurz und eindeutig ist
• nur eine schnelle Rückfrage beantwortet werden soll
• keine Auswahl, Struktur oder visuelle Führung nötig ist

So fragst du sinnvoll danach

Hilfreich sind klare Wünsche zur Darstellung, zum Beispiel:

• zeige das als Karten mit je einer Empfehlung
• stelle die Unterschiede in Tabs dar
• fasse die Zahlen als kleines Diagramm zusammen
• gib mir ein Formular mit den drei Rückfragen, die noch offen sind

Woran du gute Ergebnisse erkennst

• die Darstellung hilft beim Verstehen statt nur dekorativ zu sein
• jede Karte oder Sektion hat einen klaren Zweck
• Formulare fragen nur wirklich notwendige Dinge ab
• Diagramme zeigen nur Daten, die für die Entscheidung relevant sind

Gute erste Einsatzfälle

• Meeting-Ergebnisse als Karten mit nächsten Schritten darstellen
• Optionen in Tabs gegenüberstellen
• ein Prüf-Ergebnis als Ampel oder strukturierte Übersicht zeigen
• einfache Datensätze als Balken- oder Linienchart visualisieren

Grenzen im Alltag

MDX verbessert vor allem die Form der Antwort. Es ersetzt nicht:

• saubere Datenbasis
• gepflegtes Wissen in der Ablage
• fachliche Prüfung
• gute Aufgaben- oder Freigabeprozesse

Kurz gesagt

Nutze MDX im Chat, wenn ein Assistent Ergebnisse sichtbar strukturieren oder interaktiv darstellen soll. Für kurze, direkte Antworten bleibt normaler Chat-Text meist die bessere Wahl.

---

Ablage-Suche (RAG)

Die Ablage-Suche (RAG) hilft einem Assistenten, passende Inhalte aus Ablagen, Spaces und gepflegtem Wissen im CLYE AI zu finden und in Antworten einzubeziehen.

Wofür RAG im Alltag da ist

RAG ist besonders nützlich, wenn der Assistent nicht nur allgemein antworten, sondern mit eurem vorhandenen Wissen arbeiten soll.

Typische Fälle:

• Richtlinien, Vorlagen oder Projektdokumente einbeziehen
• Wissen aus einem Team-Space nutzen
• bestehende Notizen oder Dateien wiederfinden
• relevante Inhalte aus der Ablage statt aus dem freien Web verwenden

Woran du erkennst, dass RAG hilft

RAG ist oft die richtige Wahl, wenn du denkst:

• das müsste doch schon in unserer Ablage liegen
• der Assistent soll sich auf unsere Unterlagen stützen
• ich will nichts neu hochladen, weil es schon im Space vorhanden ist

Im Chat ist dafür oft die Funktion Ablage durchsuchen der schnellste Einstieg.

Was du dafür vorbereiten solltest

RAG funktioniert am besten, wenn Wissen gut gepflegt ist:

• Dateien liegen am passenden Ort
• Titel und Inhalte sind verständlich benannt
• veraltete Dokumente werden entfernt oder ersetzt
• wichtige Hinweise stehen nicht nur verstreut in alten Chats

So nutzt du RAG gut

Hilfreiche Formulierungen sind zum Beispiel:

• beantworte das auf Basis unserer Ablage
• nutze nur Inhalte aus dem Projekt-Space
• suche in den vorhandenen Unterlagen nach den wichtigsten Unterschieden
• stütze dich nur auf die abgelegten Richtlinien

Wann RAG besser ist als Web oder Chat-Dateien

• RAG ist besser, wenn relevantes Wissen schon im CLYE AI liegt.
• Web ist besser, wenn aktuelle externe Informationen gebraucht werden.
• Chat-Dateien sind besser, wenn eine einmalige Datei nur für diesen Chat wichtig ist.

Typische Grenzen

RAG ist keine Garantie dafür, dass automatisch immer das richtige Dokument priorisiert wird. Gute Ergebnisse hängen auch davon ab:

• wie klar du fragst
• wie sauber der Wissensbereich gepflegt ist
• ob die wirklich relevanten Inhalte überhaupt in der Ablage vorhanden sind

Gute erste Einsatzfälle

• Antwort auf Basis interner Richtlinien erzeugen
• einen bestehenden Standard aus der Ablage auf einen Fall anwenden
• relevante Stellen in vorhandenen Dokumenten zusammenfassen
• Vorlagen und Teamwissen in neue Entwürfe einfließen lassen

Kurz gesagt

Nutze Ablage-Suche (RAG) immer dann, wenn ein Assistent euer vorhandenes Wissen aus dem CLYE AI verwenden soll. Je besser die Ablage gepflegt ist, desto verlässlicher werden die Ergebnisse.

---

Memory

Memory erlaubt es einem Assistenten, sich dauerhafte Informationen zu merken. Dazu können Präferenzen, wiederkehrende Regeln, stabile Hintergründe oder wichtige Arbeitsweisen gehören.

Wofür Memory gut ist

Memory ist sinnvoll für Informationen, die nicht nur in einem einzelnen Chat gelten, sondern länger relevant bleiben.

Typische Beispiele:

• bevorzugter Stil oder Ton
• feste Begriffe oder Schreibweisen
• wiederkehrende Anforderungen eines Teams
• stabile Hintergründe zu Projekten oder Rollen

Wann du Memory statt normalen Chat-Kontext nutzen solltest

Ein normaler Chat reicht, wenn etwas nur für den aktuellen Verlauf wichtig ist.

Memory ist besser, wenn:

• dieselbe Information später wieder gebraucht wird
• du nicht bei jedem Chat von vorn erklären willst
• ein Assistent dauerhaft konsistent reagieren soll

Was sich gut merken lässt

• klare Präferenzen
• wiederkehrende Regeln
• stabile Fakten mit längerem Nutzen
• kurze, verständliche Arbeitskontexte

Was du besser nicht in Memory legst

• flüchtige Zwischenstände
• unklare Vermutungen
• sehr lange Rohtexte
• Inhalte, die eigentlich in eine gepflegte Ablage gehören

Wenn Wissen für mehrere Personen oder Prozesse wichtig ist, bleibt ein Space oft der bessere Hauptort. Memory ergänzt diesen Kontext, ersetzt ihn aber nicht.

So nutzt du Memory sinnvoll

Formuliere kurz und eindeutig, was sich der Assistent merken soll. Gute Beispiele sind:

• merke dir, dass ich Antworten eher kurz und direkt möchte
• merke dir unsere feste Produktbezeichnung
• merke dir die Prüfreihenfolge für diese Art von Anfrage

Woran du gutes Memory erkennst

• die Information bleibt auch in einigen Tagen noch nützlich
• sie ist konkret und verständlich
• sie führt zu sichtbar konsistenteren Antworten
• sie erzeugt keine unnötigen Dubletten zu bestehendem Space-Wissen

Memory prüfen und pflegen

Je nach Bereich findest du gespeicherte Notizen auch direkt in der Ablage unter Memory. Dort lässt sich besser prüfen, was dauerhaft gepflegt werden sollte und was wieder raus kann.

Spätestens wenn ein Assistent sich wiederholt auf veraltete oder zu spezielle Dinge stützt, solltest du Memory bereinigen.

Kurz gesagt

Nutze Memory für dauerhafte, kompakte Informationen, die ein Assistent über mehrere Chats hinweg konsistent berücksichtigen soll. Für umfangreiches Teamwissen bleibt ein Space die bessere Grundlage.

---

Web und Browser

Der integrierte MCP-Server Web und Browser hilft Assistenten dabei, aktuelle Informationen aus dem Web einzubeziehen oder konkrete Webseiten gezielt zu öffnen und durchzugehen.

Der einfache Unterschied

• Web ist für Suchen und aktuelle Informationen gedacht.
• Browser ist für gezieltes Öffnen und Durchgehen einzelner Seiten gedacht.

Wann du Web nutzen solltest

Web ist sinnvoll, wenn Informationen außerhalb eurer Ablage liegen oder aktuell sein müssen.

Typische Fälle:

• neue Entwicklungen prüfen
• externe Websites, Anbieter oder Veröffentlichungen vergleichen
• schnell aktuelle Fakten nachschlagen
• Ergänzungen finden, die nicht im Space liegen

Wann Browser zusätzlich hilft

Browser ist besonders nützlich, wenn eine Antwort nicht nur auf Suchtreffern beruhen soll, sondern eine konkrete Seite wirklich angesehen werden muss.

Das ist hilfreich, wenn:

• eine bestimmte Unterseite geprüft werden soll
• Inhalte auf einer Seite genauer nachvollzogen werden müssen
• mehrere Schritte auf einer Website verständlich beschrieben werden sollen

Wann du stattdessen lieber RAG nutzt

Wenn das relevante Wissen schon im CLYE AI liegt, ist Ablage-Suche (RAG) meist besser als Web.

Web ist eher der richtige Weg, wenn:

• Informationen außerhalb eures Systems liegen
• Aktualität entscheidend ist
• externe Quellen bewusst einbezogen werden sollen

So formulierst du gute Anfragen

Hilfreich sind klare Hinweise wie:

• prüfe den aktuellen Stand dazu im Web
• vergleiche drei aktuelle externe Quellen
• öffne die konkrete Seite und erkläre die wichtigsten Schritte
• nutze nur aktuelle Web-Quellen und fasse die Unterschiede zusammen

Woran du gute Ergebnisse erkennst

• der Assistent trennt klar zwischen internem Wissen und Web-Quellen
• aktuelle Informationen werden nicht als zeitlos dargestellt
• Ergebnisse bleiben überprüfbar
• die Antwort nennt klar, worauf sie sich stützt

Wichtige Grenze

Web und Browser liefern zusätzliche Informationen, aber keine automatische Freigabe für Richtigkeit. Besonders bei wichtigen Aussagen gilt weiterhin:

• Quellen prüfen
• Datum und Kontext beachten
• kritische Aussagen fachlich gegenlesen

Kurz gesagt

Nutze Web, wenn aktuelle externe Informationen gebraucht werden, und Browser, wenn eine konkrete Seite wirklich durchgegangen werden soll. Für internes Wissen bleibt RAG meist der bessere erste Schritt.

---

Code ausführen (Tool js_execute, integrierter MCP-Server „JS“)

Der integrierte MCP-Server JS 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 JS-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 JS-Server meist nicht nötig.

Gerade für effiziente Automationen ist der Server wichtig, weil du mit Code erst die billigen Schritte erledigen kannst: prüfen, filtern, deduplizieren, Felder normalisieren, Relevanz entscheiden. Ein LLM-Aufruf sollte erst danach kommen, wenn wirklich ein inhaltlicher KI-Schritt nötig ist.

Beziehung zu Automation Actions

Der Name ist etwas irreführend: Das Code-Tool läuft über den integrierten MCP-Server JS ist nicht nur für klassische Trigger-Automationen relevant, sondern auch selbst eine Quelle für Tools, die als Aktion in Automationen auftauchen können.

Das heißt praktisch:

• In einer Automation kann als Aktion ein Tool aus dem Server JS gewählt werden.
• Dazu gehören vor allem Such-, Patch- und Code-Ausführungswerkzeuge.
• Daneben können auch viele andere integrierte MCP-Server als Aktion dienen, zum Beispiel chat/send_message, event/event_dispatch, email/email_send oder task_management/task_create.

Mehr dazu:

• Katalog der integrierten MCP-Server
• Aktionen

Das Tool js_execute (JS/TS in der Sandbox ausführen)

js_execute führt TypeScript/JavaScript in einer Sandbox aus:

• keine Shell-Befehle, kein direkter Systemzugriff
• Virtuelles Dateisystem (fs) und mcp/help nur im Chat- und Playground-Profil (siehe Zwei Modi)
• MCP im klassischen Automations-Hintergrund z. B. über import { callMcpTool } from "clye.ai" (oder über tools.*, je nach Setup)
• Hilfsfunktionen für Events, Wissens-/Chunk-Operationen und (profilabhängig) fetch; Datum/JSON wie gewohnt über Standard-JavaScript (new Date(), JSON.*) bzw. über die in help() gelisteten Projekt-APIs

Zwei Modi: Chat vs. Automation (wichtig)

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

• Im Chat (interaktiver Lauf, z. B. Tool „JS/TS im Chat ausführen“)
  • fs, mcp und help stehen als Globals zur Verfügung (virtuelles Dateisystem).
  • Dateien liegen im Chat-Kontext (Uploads + Workspace).
  • HTTP/fetch ist bewusst deaktiviert (damit kein unkontrollierter Netzwerkzugriff aus der Sandbox passiert).
  • Bei addChunks: die Variante url: { fetch: "…" } (Host lädt eine URL nach) ist im gleichen Profil ebenfalls deaktiviert. Normale URL-Strings, data:-URLs sowie Blob/ArrayBuffer/Uint8Array funktionieren weiterhin.
• Im Space-JS-Playground
  • Wie Chat: fs, mcp, help; kein freies fetch; addChunks ohne { fetch: … }.
• In einer klassischen Automation (Hintergrundlauf ohne Chat-Kontext)
  • fs, mcp und help gibt es hier nicht als Globals (kein Chat-Dateisystem in diesem Profil).
  • fetch ist möglich, wenn eure Umgebung das zulässt.
  • addChunks darf url: { fetch: "…", … } nutzen (Host lädt die URL und legt die Datei ab).
  • Typisch nutzt du tools.*, Events (lastEvent / getEvents), Chunk-Helfer, import … from "clye.ai", console und das Objekt automation (siehe unten).

Dateisystem (fs)

Im Chat- und Playground-Profil steht dir das Objekt fs zur Verfügung. Im klassischen Automation-Hintergrund (ohne Chat-Kontext) ist fs kein Global — nutze dort tools.*, Events, Chunks und clye.ai, oder führe Dateizugriffe über andere Tools aus.

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 (liefert u. a. entries; das Ergebnis ist auch iterierbar)
• await fs.readdir(dir?): nur Dateinamen (einfache Liste, intern über ls mit Limit)
• await fs.stat(path): Metadaten zu einer Datei oder einem Ordner (type, size, mtime, isFile() / isDirectory())
• 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? })

API im Editor durchsuchen (help)

Nur im Chat- und Playground-Profil (wenn fs/mcp als Globals gesetzt sind):

• await help(): Überblick und Beispiele zu den Runtime-APIs
• await help("addChunks"): gezielt Signaturen und Kurzbeschreibungen (u. a. fs, mcp, Chunk-Funktionen, Event-Typen)

MCP-Tools nutzen (mcp)

Im Chat- und Playground-Profil: Wenn in eurem Space MCP-Server verbunden sind, kannst du sie über das Global mcp verwenden:

• await mcp.tools() listet verfügbare Tools (Name + Beschreibung).
• await mcp.call("serverName/toolName", { ...args }) ruft ein Tool auf. Erlaubt ist auch die Schreibweise serverName:toolName (Doppelpunkt statt Slash).

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
  • limit: optional, Standard 50, maximal 500
  • cursor: Sequenznummer (string) des letzten Events der vorherigen Seite (wie nextCursor in der Antwort)
  • direction: "desc" (Standard, neueste zuerst) oder "asc"

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. Die Logik entspricht grob dem Schreibpfad des RAG-Patch-Tools: bestehende Chunks mit derselben id werden überschrieben bzw. neu indexiert.

await addChunks(chunks)

Parameter: Array von Objekten (ChunkInput):

Feld	Bedeutung
id	Eindeutige ID des Chunks (wird intern in eine UUID übernommen).
text	Textinhalt für die Indexierung. Wenn weggelassen, wird kein neuer Text geschrieben, sondern ein Re-Index des bestehenden Chunks ausgelöst (z. B. nach Aktualisierung der url).
url	Optional: Referenz oder Binärdaten. Unterstützt u. a.: normale URL-Strings (https://…, interne Pfade wie /f/…), data:-URLs (werden automatisch hochgeladen und durch dauerhafte /f/…-Links ersetzt), Blob / ArrayBuffer / Uint8Array (Upload), Response-ähnliche Objekte (Bytes werden übernommen), sowie { fetch: string, init?: RequestInit, filename?: string, mime?: string } — nur im Automation-Profil (Host lädt die URL; im Chat/Playground deaktiviert).
metadata	Optionale Schlüssel/Werte (z. B. Dateiname/MIME-Hinweise bei Binärimport).
addedAutomatically	Ob der Chunk als automatisch angelegt gilt (Standard: true).

Rückgabe: { chunkIds: string[] } — UUIDs der angelegten bzw. verarbeiteten Chunks.

await deleteChunk(chunkId) / await deleteChunks(chunkIds)

Löscht einen bzw. mehrere Chunks dauerhaft. Rückgabe jeweils mit deletedCount.

Typische Nutzung:

• Ergebnisse als neue Wissenskarte/Chunk ablegen
• veraltete automatische Chunks aufräumen
• Inhalte nach erneuter Verarbeitung re-indexieren (text weglassen oder url/text aktualisieren)

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.

Datum, Zeit und JSON

In der Sandbox steht dir normales JavaScript zur Verfügung — typischerweise new Date(), JSON.stringify / JSON.parse und die üblichen eingebauten Objekte der QuickJS-/Node-Kompatibilitätsschicht.

Zusätzlich pflegt der Bot in den TypeScript-Deklarationen (Autocomplete im Code-Editor) und in await help("…") (nur Chat/Playground) weitere Namen wie now, addDays, formatDate, parseJson, coalesce, usw. Welche davon zur Laufzeit wirklich als globale Funktion gebunden sind, kann vom Ausführungspfad und der Bot-Version abhängen — für portable Skripte sind die Standard-APIs die zuverlässigste Wahl.

Automation-Kontext (automation)

Im Sandbox-Code existiert die Konstante automation mit u. a.:

• id — ID der Automation (z. B. für Abfragen früherer Läufe derselben Automation)
• spaceId — Space
• userId / actorId — auslösender Nutzer bzw. Actor (falls gesetzt)

Modul clye.ai (Import)

Neben den Globals kannst du aus "clye.ai" importieren (QuickJS-Bundling im Bot):

• dispatchEvent(event) — Event im Space auslösen (type, optional objectId, data, metadata, causedBy, timestamp, id für Idempotenz)
• callMcpTool(serverName, toolName, input) — MCP-Tool aufrufen
• getMcpResource(serverName, uri) — MCP-Ressource lesen (text/blob/Metadaten)
• lastEvent / getEvents — dieselben Event-Helfer wie global (wenn du sie explizit aus dem Modul beziehen willst)

Effizient bauen: erst Code, dann LLM

Ein wichtiger Grundsatz für produktive Automationen ist: Regeln und Code zuerst, LLM nur wenn nötig.

Das bedeutet typischerweise:

• zuerst prüfen, ob sich überhaupt etwas geändert hat
• zuerst filtern, ob ein Treffer fachlich relevant ist
• zuerst einfache Entscheidungen mit Code treffen
• erst danach chat/send_message oder einen anderen LLM-basierten Schritt aufrufen

Beispiel:

• Ein Postfach wird regelmäßig geprüft.
• Code erkennt zuerst, ob es neue E-Mails gibt und ob darunter überhaupt interessante Nachrichten sind.
• Nur diese relevanten Nachrichten werden anschließend an einen Assistenten zur Zusammenfassung oder Antwortvorbereitung gegeben.

So bleibt die Automation effizient, ohne auf Qualität zu verzichten.

dispatchEvent (fortgeschritten)

In manchen Setups kann ein Skript auch Events auslösen — per import { dispatchEvent } from "clye.ai" (siehe Abschnitt Modul clye.ai (Import) weiter oben). Wenn ihr das nutzt, macht das am besten nur in klar definierten Automationen.

Ein sehr gutes Muster ist dabei:

• Code erkennt zuerst eine Änderung oder einen fachlich relevanten Fall.
• Danach wird ein eigenes Event dispatcht.
• Eine andere Automation reagiert auf dieses Event.

Beispiel:

• Ein Code-Schritt erkennt drei geänderte Dateien.
• Er dispatcht drei getrennte Events.
• Weitere Automationen können diese Änderungen unabhängig voneinander verarbeiten.

Das macht Abläufe meist einfacher, retrybarer und besser erweiterbar als eine einzige große Automation mit vielen direkten Folgeschritten.

Beispiele

Beispiel: Cross-Assistant-Dateizugriff (Ordner aus einem anderen Space listen und indexieren)

Manchmal liegt ein Dateisystem-Zugriff (z. B. über einen Filesystem-Connector) in einem anderen Assistenten/Space. Wenn du trotzdem gezielt einzelne Ordner in deinem aktuellen Assistenten indexieren möchtest, kannst du MCP-Tools raumübergreifend aufrufen.

Begriffe

• Base-Assistent: Assistent/Space, der Zugriff auf das Dateisystem hat.
• Specific-Assistent: Assistent/Space, der nur einen Teil davon (z. B. bestimmte Ordner) nutzen bzw. indexieren soll.

Voraussetzungen

1. Öffne im Specific-Assistenten: Einstellungen → Berechtigungen.
2. Lade den Base-Assistenten ein (damit der Specific-Assistent dessen MCP-Server/Tools verwenden darf).

Optional (Best Practice): Wenn im Base-Assistenten bisher „alles“ indexiert wird, kannst du in dessen Indexierungs-Automationen die Inhalte, die künftig „spezifisch“ verarbeitet werden sollen, ausklammern (z. B. Ordner exkludieren), damit nichts doppelt läuft.

MCP-Server-ID ermitteln

Die Server-ID findest du im Specific-Assistenten unter Einstellungen → MCP-Server:

1. MCP-Server auswählen
2. Auf das Zahnrad klicken
3. Den Wert bei Server-Id kopieren

Tool-Aufruf im Automation-Code

Im Automation-Code rufst du das Tool über callMcpTool auf und gibst dabei zusätzlich die spaceId des Base-Assistenten an.

Parameter:

• serverName: Name/ID des MCP-Servers (wie in den Einstellungen angezeigt)
• toolName: Name des Tools auf diesem MCP-Server (z. B. list_directory)
• input: Parameter-Objekt für das Tool
• baseSpaceId: spaceId des Base-Assistenten (z. B. aus der URL des Base-Spaces)

const res = await process.env.callMcpTool(
  "Filesystem Connector",
  "list_directory",
  {
    include_hidden: false,
    path: "Vertrieb",
    recursive: true,
  },
  "123abc456-7899-56ec-bcdb-ef11801750b1"
);

Mit dem Ergebnis kannst du anschließend wie gewohnt Events dispatchen und diese in einer zweiten Automation indexieren lassen.

Empfehlung: Idempotenz beim Dispatch & Indexing

Wenn du pro Datei (oder pro gefundenem Objekt) ein Event auslöst und danach indexierst, achte darauf, dass du:

• eine eindeutige objectId für das Event verwendest, damit Wiederholungen nicht zu Fehlern/Dubletten führen
• beim Indexieren eine eindeutige uri verwendest

Praktisches Muster: einen Prefix voranstellen, z. B. "company-" + uri.

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, Chat)

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 JS 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.

---

Katalog der integrierten MCP-Server

Diese Seite dokumentiert die eingebauten MCP-Server des CLYE AI möglichst vollständig. Gemeint sind die Server, die direkt im Produkt definiert werden und technisch als createVirtualMcpServer(...) entstehen.

Wichtig:

• Nicht jeder integrierte MCP-Server ist in jedem Setup sichtbar.
• Manche Server sind nur für Admins, interne Workflows oder spezielle Spaces gedacht.
• Nicht jeder Server ist gleichermaßen sinnvoll als Automation Action.

Wie das mit Automation Actions zusammenhängt

Wenn ein integrierter MCP-Server echte Tools bereitstellt, erscheinen diese Tools typischerweise auch in der Aktion-Auswahl von Automationen.

Praktisch heißt das:

• Der Server ist die Quelle oder Gruppe.
• Das Tool ist die konkrete Automation Action.
• In technischen IDs ist das meist server/tool, zum Beispiel:
  • chat/send_message
  • email/email_send
  • event/event_dispatch
  • task_management/task_create

Faustregel:

• Datasource-Server liefern oft Wissen oder Suchfunktionen.
• Action-Server führen eher Änderungen, Benachrichtigungen oder Prozessschritte aus.
• Manche Server können beides.

Für die Auswahl im Automationsdialog siehe auch:

• Aktionen
• Für technische Nutzer

Schnellüberblick

Server-ID	Titel	Typischer Zweck	Als Automation Action?
rag	RAG	Wissenssuche in Ablage/Space	ja, oft für Recherche- oder Vorverarbeitungsschritte
memory	Memory	dauerhafte Notizen / Kontext	eingeschränkt, eher Spezialfall
web	Web	Websuche und Seiten öffnen	ja, aber mit Bedacht
browser	Browser	Browser-Interaktion	eher selten, nur wenn UI-Schritte nötig sind
sharepoint	SharePoint	Suche und Lesen in SharePoint	ja
database	Datenbank	SQL-Abfragen	ja
folder	Ordner	lokaler Ordnerzugriff	ja, wenn im Setup freigegeben
workspace_fs	Workspace-Dateisystem (virtuell)	Dateien lesen, patchen, löschen	ja
space_fs	Space-Dateisystem (Shell)	Shell-artige Dateioperationen im Space	ja
automation	Automation	Automationen suchen/ändern, JS/TS ausführen	ja
chat	Chat	Nachrichten an Chats senden	ja, sehr häufig
task_management	Aufgabenverwaltung	Aufgaben anlegen, suchen, aktualisieren	ja
event	Events	Events lesen und auslösen	ja
email	Email	E-Mails versenden	ja
push_notifications	Push-Benachrichtigungen	Web-Push verschicken	ja
template	Template	Vorlagen abrufen und ausfüllen	ja
form	Form	Formulare und dokumentnahe Eingaben	eingeschränkt
vision	Vision	Bildanalyse	ja
website_index	Website-Index	Websites indexieren und bereinigen	ja
chunk	Chunk	Chunks indexieren oder invalidieren	ja
skill	Use Skills	Skills anwenden	ja
skillAdmin	Skill Admin Tools	Skills erstellen/suchen/patchen	eher admin-/editor-nah
feedback	Feedback	Feedback einreichen und eigenes Feedback lesen	ja
feedbackAdmin	Feedback Admin	Feedback verwalten und Insights	eher admin-/editor-nah
mcp	Manage local MCP servers	MCP-Server installieren, entfernen, listen	eher Admin/Setup
custom	Custom	eigene JS/TS-Tools	ja, für fortgeschrittene Setups
http	Web Request	erlaubte HTTP-Requests	ja
parallel	Parallel	mehrere Tools parallel ausführen	ja
current_time	Aktuelle Uhrzeit	Zeit/Datum	ja
ask	Fragen stellen	strukturierte Rückfragen an Nutzer	im Hintergrund meist unpassend
ask_questions	Fragen an Ersteller	Rückfragen an Content Owner	eher Chat-/Q&A-orientiert
mdx	MDX in Chat	UI-Komponenten im Chat rendern	nein, primär Darstellung
bot	Assistenten erstellen	neue Assistenten anlegen	eher Admin/Builder
nanobana	Nanobana	Bildgenerierung über Nanobana	ja
admin	Admin	Admin-Operationen	nur Admin
test	Test	interner Testserver	nein, nur intern
store	Manage local MCP servers	Store-nahe MCP-Installation	eher intern
show_planning	Planung anzeigen	To-do-/Planungsanzeige	eher Chat-orientiert

Wissens- und Datenserver

Diese Server sind vor allem für Suche, Lesen, Kontext und Datenzugriff gedacht.

rag, RAG

Zweck:

• Inhalte aus Ablage, Space und Wissen finden
• auf gepflegtes internes Wissen statt freies Web zugreifen

Typische Tools:

• rag_search
• je nach Setup zusätzliche schreibende RAG-/Chunk-Funktionen

Als Automation Action:

• gut für Recherche-, Prüf- oder Anreicherungs-Schritte
• oft vor chat/send_message, template/template_fill oder Export-Schritten sinnvoll

Mehr dazu:

• Ablage-Suche (RAG)

memory, Memory

Zweck:

• dauerhafte Notizen, Präferenzen und stabilen Kontext pflegen

Typische Tools:

• memorize

Als Automation Action:

• möglich, aber gezielt einsetzen
• sinnvoll, wenn ein Automation-Lauf bewusst dauerhafte Erkenntnisse speichern soll
• nicht als allgemeines Protokoll missbrauchen

Mehr dazu:

• Memory

web, Web

Zweck:

• Websuche
• konkrete URLs öffnen und lesen

Typische Tools:

• web_search
• web_open_url

Als Automation Action:

• technisch möglich
• sinnvoll für aktuelle externe Daten
• vorsichtig bei Stabilität, Reproduzierbarkeit und Quellenschwankungen

Mehr dazu:

• Web und Browser

browser, Browser

Zweck:

• Seiten nicht nur lesen, sondern interaktiv durchgehen

Typische Tools:

• browser_use

Als Automation Action:

• möglich, aber eher Spezialfall
• sinnvoll nur, wenn ein UI-basierter Webablauf wirklich nötig ist
• weniger robust als API- oder HTTP-basierte Integrationen

sharepoint, SharePoint

Zweck:

• Inhalte in SharePoint suchen, lesen und zusammenfassen

Typische Tools:

• sharepoint_search
• sharepoint_read
• sharepoint_overview

Als Automation Action:

• gut für Dokumentenrecherche, Inbox-/Portal-Sync, Vorprüfung und Zusammenfassungen

database, Datenbank

Zweck:

• SQL-Abfragen auf verbundene Datenbanken

Typische Tools:

• sql_query
• sql_table_info
• sql_tables

Als Automation Action:

• sehr gut für technische Workflows
• nützlich für Prüfungen, Reports, Datenanreicherung und Query-basierte Entscheidungen

folder, Ordner

Zweck:

• lokaler Ordnerzugriff

Typische Tools:

• ordner-/dateibezogene Lesezugriffe aus dem freigegebenen Kontext

Als Automation Action:

• nützlich, wenn Automationen auf lokale Ordnerstrukturen zugreifen sollen
• stark von eurem Setup und den Freigaben abhängig

Kommunikations- und Prozessserver

Diese Server lösen häufiger direkte Aktionen oder Folgeprozesse aus.

chat, Chat

Zweck:

• Nachrichten an Chats senden
• LLM-Antworten in bestehenden oder neuen Chats auslösen

Typische Tools:

• send_message

Als Automation Action:

• einer der wichtigsten Server für Automationen
• ideal für HTTP-Trigger, Event-Reaktionen, externe Fälle und Assistenz-Workflows

Mehr dazu:

• Aktionen

task_management, Aufgabenverwaltung

Zweck:

• Aufgaben anlegen, finden, lesen, aktualisieren, löschen

Typische Tools:

• task_create
• task_get
• task_find
• task_update
• task_delete
• task_get_comments

Als Automation Action:

• sehr gut geeignet
• typischer Standardserver für Workflow- und Nachverfolgungsautomationen

event, Events

Zweck:

• Events lesen, auswerten und neue Events veröffentlichen

Typische Tools:

• event_list
• event_get
• event_get_related
• event_get_types
• event_get_stats
• event_dispatch

Als Automation Action:

• sehr stark für eventgetriebene Architekturen
• nützlich, wenn ein Schritt bewusst Folgeevents erzeugen soll

email, Email

Zweck:

• E-Mails senden
• optional mit erlaubten Empfängern, Standardempfängern und Anhängen

Typische Tools:

• email_send

Als Automation Action:

• sehr gut geeignet
• klassischer Zielserver für Benachrichtigungen, Freigaben, Reports und externe Kommunikation

push_notifications, Push-Benachrichtigungen

Zweck:

• Web-Push an Nutzer senden

Typische Tools:

• push_notification_send

Als Automation Action:

• gut für kurze, direkte Benachrichtigungen

feedback und feedbackAdmin

Zweck:

• Feedback erfassen, listen, aktualisieren und auswerten

Typische Tools:

• feedback_submit
• feedback_list_mine
• feedback_list
• feedback_update
• feedback_insights

Als Automation Action:

• gut für Qualitäts- und Review-Schleifen
• feedbackAdmin ist eher für administrative Auswertung gedacht

template, Template

Zweck:

• Vorlagen abrufen und ausfüllen

Typische Tools:

• template_get
• template_fill

Als Automation Action:

• sehr sinnvoll für dokumentnahe Prozesse
• gut kombinierbar mit database, sharepoint, rag oder chat

form, Form

Zweck:

• Formular-gestützte Dokument- oder Eingabeflüsse

Typische Tools:

• formularbezogene Tools aus dem Embed-/Form-Kontext

Als Automation Action:

• eher Spezialfall
• sinnvoll, wenn ein Workflow bewusst auf strukturierte Eingaben oder Dokumenterstellung zielt

ask, Fragen stellen

Zweck:

• dem Nutzer strukturierte Rückfragen mit Antwortoptionen stellen

Typische Tools:

• ask

Als Automation Action:

• technisch vorhanden
• für Hintergrund-Automationen meist nicht passend
• eher für interaktive Chat- oder Copilot-artige Flows geeignet

ask_questions, Fragen an Ersteller

Zweck:

• Rückfragen an den Ersteller oder Content-Verantwortlichen notieren

Typische Tools:

• rag_request_entry

Als Automation Action:

• eher Spezialfall
• nützlich, wenn offene Wissenslücken formal in Q&A oder Content-Pflege überführt werden sollen

Automations-, Datei- und Entwickler-Server

Diese Server sind besonders für technische Nutzer und Builder interessant.

automation, Automation

Zweck:

• Automationen suchen, patchen, generieren oder Code ausführen

Typische Tools:

• automation_search
• automation_trigger_event_search
• automation_patch
• js_execute

Als Automation Action:

• sehr mächtig
• vor allem für Builder-Setups, Meta-Automationen und JS/TS-Ausführung geeignet

Mehr dazu:

• Automationen und Code

workspace_fs, Workspace-Dateisystem (virtuell)

Zweck:

• Dateien lesen, durchsuchen, patchen und löschen

Typische Tools:

• glob
• grep
• read
• applyPatch
• delete

Als Automation Action:

• sehr nützlich für dokumenten-, datei- oder codebezogene Workflows

space_fs, Space-Dateisystem (Shell)

Zweck:

• shell-artige Dateioperationen im Space-Dateisystem

Typische Tools:

• fs_shell

Als Automation Action:

• stark für technische Dateiflüsse
• mit Vorsicht einsetzen, weil es ein mächtigerer, shell-naher Zugriff ist

custom, Custom

Zweck:

• eigene JS/TS-Tools definieren

Typische Tools:

• dynamisch aus dem hinterlegten Code erzeugte Funktionen

Als Automation Action:

• sehr gut für fortgeschrittene Teams
• sinnvoll, wenn Standard-Tools nicht ausreichen, aber wiederverwendbare Logik gebraucht wird

parallel, Parallel

Zweck:

• mehrere Tool-Aufrufe parallel ausführen

Typische Tools:

• parallel

Als Automation Action:

• gut für performance-sensitive oder voneinander unabhängige Teilaufrufe
• nur nutzen, wenn Parallelität fachlich sicher ist

http, Web Request

Zweck:

• HTTP-Requests an vorher definierte, erlaubte Endpunkte

Typische Tools:

• http_request

Als Automation Action:

• sehr wichtig für Integrationen
• oft der direkte Weg zu Dritt- oder Inhouse-APIs

current_time, Aktuelle Uhrzeit

Zweck:

• aktuelles Datum und aktuelle Uhrzeit beziehen

Typische Tools:

• get_current_time

Als Automation Action:

• hilfreich für Zeitstempel, Berichte, Datumslogik und Vorlagen

vision, Vision

Zweck:

• Bilder oder visuelle Inhalte analysieren

Typische Tools:

• vision_analyze_image

Als Automation Action:

• gut für bildbezogene Prüfungen, OCR-nahe Analysen oder visuelle Vorverarbeitung

website_index, Website-Index

Zweck:

• Websites indexieren oder bereinigen

Typische Tools:

• index_website
• cleanup_website_chunks

Als Automation Action:

• gut für Content-Ingestion und Pflege von Webwissen

chunk, Chunk

Zweck:

• Chunks neu erzeugen oder invalidieren

Typische Tools:

• index_chunk
• invalidate_chunk

Als Automation Action:

• sinnvoll für RAG- und Ingestion-Workflows

skill und skillAdmin

Zweck:

• Skills anwenden oder administrativ verwalten

Typische Tools:

• skill_use
• skill_create
• skill_search
• skill_get
• skill_patch

Als Automation Action:

• skill ist gut für standardisierte Arbeitsweisen
• skillAdmin eher für Builder- und Pflegeprozesse

show_planning, Planung anzeigen

Zweck:

• Todo-/Planungslisten im Chat sichtbar machen

Typische Tools:

• todo_write

Als Automation Action:

• eher Chat- und Transparenzfunktion
• für Hintergrundautomationen selten die eigentliche Kernaktion

Assistenten-, UI- und Medienserver

mdx, MDX in Chat

Zweck:

• interaktive UI-Komponenten direkt im Chat rendern

Typische Funktion:

• liefert primär Instructions, keine eigentlichen Action-Tools

Als Automation Action:

• nein, nicht als klassische Automation Action gedacht

Mehr dazu:

• MDX im Chat

bot, Assistenten erstellen

Zweck:

• neue Assistenten erzeugen oder bot-nahe Builder-Funktionen ausführen

Als Automation Action:

• eher für Builder- und Verwaltungsflüsse
• nicht typischer Standard in Fachautomationen

Mehr dazu:

• Bot Father: Assistenten erstellen und verwalten

nanobana, Nanobana

Zweck:

• Bildgenerierung über die Nanobana-API

Typische Tools:

• nanobana_generate_image

Als Automation Action:

• gut für kreative oder mediennahe Workflows, wenn Nanobana im Setup vorhanden ist

Admin- und interne Server

Diese Server sind meist nicht für normale Endnutzer gedacht.

mcp, Manage local MCP servers

Zweck:

• MCP-Server installieren, entfernen und auflisten

Typische Tools:

• install_mcp_server
• uninstall_mcp_server
• list_mcp_servers

Als Automation Action:

• eher Setup-/Admin-Thema

admin, Admin

Zweck:

• administrative Operationen wie Bereinigung oder spezielle Benachrichtigungen

Typische Tools:

• clean_sandboxes
• clean_chunks
• send_feedback_notification

Als Automation Action:

• nur für Admin-Kontexte

store, Manage local MCP servers

Zweck:

• store-nahe Installation lokaler MCP-Server
• derzeit eher als interne oder produktnahe Hilfsfunktion einzuordnen als als normaler Endnutzer-Server

Typische Tools:

• install_mcp_server

Als Automation Action:

• eher intern oder für spezielle Setup-Flows

test, Test

Zweck:

• interner Testserver

Typische Tools:

• timeout_test

Als Automation Action:

• nein, nur intern

Welche Server zuerst relevant sind

Für die meisten produktiven Setups sind zuerst diese Server wichtig:

• rag
• chat
• task_management
• event
• email
• http
• template
• sharepoint
• database
• automation

Für fortgeschrittene technische Teams kommen oft dazu:

• workspace_fs
• space_fs
• parallel
• custom
• website_index
• vision

Kurz gesagt

Die integrierten MCP-Server sind nicht nur Chat-Zusatzfunktionen, sondern zugleich der Werkzeugkasten für Automationen. Sobald ein Server echte Tools mitbringt, tauchen diese typischerweise als mögliche Automation Actions auf. Für produktive Automationen sind besonders chat, task_management, event, email, http, template, database, sharepoint und automation relevant.