Zum Hauptinhalt springen
connic
Starte kostenlos

Ein Chat-Agent, der Dashboards neben dem Gespräch baut

Ein Chat-Agent baut Dashboards, Diagramme und kleine Tools neben dem Gespräch, mit Bibliotheken, die Modelle kennen, Designregeln und einer Sichtprüfung.

20. November 20269 Min. LesezeitAutor: connic engineering

Wer einen Assistenten nach einem Umsatzdiagramm fragt, bekommt in den meisten Chats eine Tabelle in Markdown. Ein connic-Agent kann stattdessen eine echte Seite bauen: Er veröffentlicht statische Dateien als Instanz einer App, und der Chat zeigt diese Seite in einem Bereich neben dem Gespräch. Jede Änderung, um die du bittest, landet auf derselben Seite unter derselben Adresse. Dieses Tutorial baut das Setup aus der Vorlage chat-page-builder auf und zeigt, wodurch die Seiten fertig aussehen.

Was du baust

Die Chat-App hat zwei Teile. Links läuft das Gespräch. Rechts öffnet sich ein Bereich mit der Seite, die der Agent gebaut hat: ein Dashboard, ein Bericht, ein Rechner oder ein Tracker. Jede Seite hat eine eigene Adresse, funktioniert auch nach dem Chat weiter und kann Live-Daten lesen oder speichern, was jemand einträgt. Bittet jemand um eine Änderung, veröffentlicht der Agent eine neue Version unter derselben Adresse.

Die Vorlage besteht aus zwei Agenten, zwei Apps, einem WebSocket-Connector und einer Beispielseite:

project
chat-page-builder/
├── agents/
│   ├── chat-assistant.yaml    # schnelles Modell: Gespräch und Daten
│   └── page-designer.yaml     # stärkeres Modell: gestaltet, veröffentlicht, prüft
├── apps/
│   ├── chat.yaml, chat/       # der Chat mit dem Seitenbereich
│   └── pages.yaml, pages/     # die Basis, die jede Seite lädt
├── connectors/
│   └── assistant-chat.yaml    # WebSocket, den nur die Chat-App öffnen kann
└── page-examples/
    └── dashboard/             # Beispielseite für Files

Warum generierte Seiten unfertig wirken

Baut ein Agent eine Seite von Grund auf, sieht sie oft generiert aus, und das liegt selten am Modell. Der Agent schreibt gegen ein Komponenten-Kit, das es nie gesehen hat, und rät dessen API. Sein Prompt enthält ein, zwei Sätze zum Design. Und niemand sieht sich die Seite an, bevor die Person sie öffnet, die danach gefragt hat.

Die Vorlage setzt an allen drei Stellen an. Die Seitenbasis bringt Bibliotheken mit, die Modelle bereits gut schreiben, der Designer arbeitet mit echten Designregeln und einer Beispielseite, und er sieht sich seine Seite an, bevor er antwortet.

Eine Seitenbasis mit Bibliotheken, die Modelle kennen

Seiten sind Instanzen der Pages-App. Mit instances_only liefert diese App nur die Seiten aus, die Agenten veröffentlichen, jede unter einem eigenen Pfad. Ihr Build ist die gemeinsame Basis: der Browser-Build von Tailwind CSS, Chart.js, Lucide-Icons, die Schrift Inter und eine Theme-Datei, bei jedem Deployment aus npm kopiert.

apps/pages.yaml
name: Pages
instances_only: true        # liefert nur die Seiten aus, die Agenten veröffentlichen
build:
  command: npm run build    # kopiert Tailwind, Chart.js, Lucide und das Theme nach /lib/
  output: dist
auth:
  mode: connic
embed:
  origins:
    - https://chat-1a2b3c4d.connic.app   # der Chat darf Seiten im Frame zeigen

Die Bibliotheken kommen vom eigenen Host der App. Deshalb laufen die Seiten unter der Standard-Content-Security-Policy, die Skripte nur von diesem Host erlaubt. Keine der drei Bibliotheken braucht ein CDN oder eval. Jede Seite beginnt mit demselben Head:

index.html
<link rel="stylesheet" href="/lib/page.css">
<script src="/lib/tailwind.js"></script>
<script src="/lib/chart.js"></script>
<script src="/lib/lucide.js"></script>
<script src="/lib/page.js"></script>
<script type="module" src="./app.js"></script>

page.js enthält das Theme: neutrale Farben mit einer Akzentfarbe, Diagrammfarben in fester Reihenfolge und Chart.js-Vorgaben für Schrift, Gitterlinien, Tooltips, abgerundete Balken und dünne Linien. Jede Seite lädt die Datei aus der Basis. Eine neue Akzentfarbe erreicht deshalb mit dem nächsten Deployment alle veröffentlichten Seiten. Agenten veröffentlichen ihre Dateien so, wie sie sie schreiben, ohne Build-Schritt. Seiten nutzen also einfache JavaScript-Module und kein JSX.

Ein Agent redet, einer gestaltet

Eine gute Seite braucht ein starkes Modell, hohen Reasoning-Aufwand und ein, zwei Minuten. Ein Chat, der bei jeder Antwort so lange wartet, fühlt sich zäh an. Die Vorlage teilt die Arbeit deshalb auf. chat-assistant läuft auf einem schnellen Modell, beantwortet Fragen, liest und speichert die Daten der Person und ruft den Designer mit trigger_agent auf, sobald eine Seite gebraucht wird:

trigger_agent-Payload
{
  "brief": "Monatsumsätze von sechs Cafés. Zuerst der Umsatz im Vergleich zum Vorjahr, dann Umsatz nach Produkt und eine Rangliste der Filialen. Deutsch.",
  "dataset": {
    "collection": "page_data",
    "dataset": "shop-sales",
    "fields": ["month", "store", "product", "revenue"]
  }
}

Das Briefing sagt, wofür die Seite da ist und womit sie beginnen soll. Kleine, feste Daten gehen als data mit. Daten, die live bleiben sollen oder die die Person später ändert, landen zuerst in der Collection page_data, und die Payload nennt nur den Datensatz. Die Seite liest diese Zeilen dann selbst über die Data API, sodass Änderungen beim nächsten Neuladen sichtbar sind.

page-designer läuft auf einem stärkeren Modell mit hohem Reasoning-Aufwand. Steht die Pages-App unter apps, bekommt er die Tools app_publish und app_preview. app_publish beschreibt dem Modell die App von selbst, mit Anmeldung, Datenendpunkten und Zugriffsregeln:

agents/page-designer.yaml
name: page-designer
model: connic/claude-opus-5.5
reasoning_effort: high
output_schema: page-result
tools:
  - file_list
  - file_read
  - file_write
apps:
  - app: pages               # bringt app_publish und app_preview mit
    user: context.end_user   # app_publish liefert zusätzlich einen Embed-Link für diese Person

Mit user: context.end_user liefert app_publish neben der Adresse der Seite einen Embed-Link, der als die Person im Chat angemeldet ist. Agenten, die über trigger_agent starten, handeln für dieselbe Person, also baut der Designer für genau die Person, die gefragt hat. Sein Output Schema legt fest, was er zurückgibt: Titel, Adresse, Embed-Link, Instanz-ID und Ordner. chat-assistant merkt sich diese Angaben, um die Seite später zu ändern.

Designregeln und ein Beispiel zum Abschauen

Der größte Teil im Prompt des Designers sind Designregeln, nicht der Ablauf. Die Regeln sind kurz und konkret:

aus page-designer.yaml
Color, one accent:
- primary is the accent. Use it for the one thing to look at: the main
  series, the active control, the main button.
- text-success and text-destructive only for good and bad, always with a
  sign or an icon, never to tell categories apart.
Charts:
- Every canvas sits in a div with a fixed height (h-64 or h-72).
- Change over time is a line; comparing categories is a bar; a single
  number is a stat, not a chart.
- At most six series, one y axis, a legend only for two or more series.

Weitere Regeln betreffen Schriftgrößen, Abstände, Karten, Tabellen sowie die Zustände für Laden, keine Daten und Fehler, die jede Seite mit Daten braucht. Ein Beispiel-Dashboard zeigt all das in funktionierendem Code. Es liegt in Files unter page-examples/, und der Designer liest vor dem Schreiben das Beispiel, das am besten zur Anfrage passt. Lege dort eigene Beispiele ab, etwa einen Bericht im Layout deines Unternehmens, und der Designer nutzt sie ohne neues Deployment.

Der Designer sieht sich seine Seite an

Code, der gut aussieht, kann trotzdem schlecht rendern: eine abgeschnittene Beschriftung, ein Diagramm, das zu einem schmalen Streifen zusammenfällt, ein Icon-Name, den es nicht gibt. Nach jedem Veröffentlichen ruft der Designer app_preview auf, das connic neben app_publish bereitstellt. Das Tool öffnet die Seite als die Person im Chat und liefert einen Screenshot der ganzen Seite, die Fehler und Warnungen aus der Konsole und nicht abgefangene Skriptfehler. Blockiert die Content Security Policy eine Datei, steht auch das in den Warnungen. Was ihm auffällt, korrigiert der Designer und veröffentlicht erneut unter derselben Adresse, höchstens zweimal.

Die Vorschau läuft in einem Browser in der Cloud und zählt als Browser-Nutzung. Seiten, die bei der lokalen Entwicklung von deinem eigenen Rechner kommen, erreicht sie nicht. Dort lässt der Designer die Prüfung aus und vermerkt das in seinen Hinweisen.

Die Seite neben dem Chat zeigen

Die Chat-App spricht mit chat-assistant über einen WebSocket-Connector mit apps_only, den nur diese App öffnen kann. Fortschrittsereignisse melden dem Chat, was der Assistent gerade tut. So zeigt er mit einer Zeitanzeige an, dass die Seite gerade entsteht, während der Designer arbeitet. Jede Antwort endet mit einem Markdown-Link zur Seite. Der Chat macht aus Links auf veröffentlichte Seiten Karten und öffnet die neueste im Seitenbereich.

apps/chat.yaml
name: Page builder
build:
  command: npm run build
  output: dist
auth:
  mode: connic
connectors:
  - assistant-chat
content_security_policy: "default-src 'self'; script-src 'self'; ... frame-src https://*.connic.app; frame-ancestors 'self'; ..."

Der Seitenbereich ist ein iframe, und zwei Einstellungen erlauben ihn. Die Pages-App führt die Adresse des Chats unter embed.origins, und die content_security_policy der Chat-App ergänzt den Host der Pages-App unter frame-src. Der Embed-Link meldet den Bereich als die Person im Chat an, niemand muss sich also zweimal anmelden. Wie du die Seite zeigst, entscheidest du selbst: Derselbe Link funktioniert auch in deinem eigenen Produkt, solange dessen Adresse in embed.origins steht.

Seiten und Daten jeder Person getrennt halten

Alle nutzen dieselben Agenten, Apps und Collections, und Zugriffsregeln halten die Daten auseinander. chat-assistant darf nur Zeilen in page_data lesen und ändern, die der Person gehören, mit der er gerade spricht, und set trägt diese Person bei jeder neuen Zeile als Eigentümer ein. Veröffentlichte Seiten lesen dieselben Zeilen unter derselben Regel. Was jemand auf einer Seite speichert, etwa abgehakte Gewohnheiten oder Notizen, landet in page_state:

apps/pages.yaml
access:
  database:
    page_data:                    # Zeilen, die chat-assistant für Live-Seiten speichert
      read: doc.owner == user.id
    page_state:                   # was Personen auf einer Seite speichern
      read: doc.owner == user.id
      insert: true
      update: doc.owner == user.id
      delete: doc.owner == user.id
      set:
        owner: user.id

Der Designer speichert den Quellcode jeder Seite mit demselben Eigentümer in Files. Arbeitet er für jemand anderen, kann er fremde Seiten weder lesen noch ändern.

Loslegen

  1. connic-Plugin installieren. Überspring diesen Schritt, wenn dein Coding-Agent es schon hat. Füge das in Claude Code, Codex oder Cursor ein:

    prompt
    Installiere das connic-Plugin aus connic-org/connic-skill und erkläre dem Nutzer, wie er die MCP-Authentifizierung abschließt.
  2. Mit der Vorlage starten. Füge das in eine neue Session ein. Der Agent zeigt dir die Vorlage, passt sie mit dir an deine Daten an und deployt sie:

    prompt
    Ich möchte mit der connic-Vorlage chat-page-builder starten, einer Chat-App, in der ein Agent Dashboards und kleine Tools neben dem Gespräch baut. Zeig mir, was sie enthält, frag mich, was meine Seiten zeigen sollen und woher ihre Daten kommen, und schlag die Änderungen vor. Sobald wir uns einig sind, richte sie in diesem Ordner mit `connic init --templates=chat-page-builder` ein, passe sie an, installiere die Abhängigkeiten der Apps, prüfe sie und deploye sie in mein connic-Projekt. Lade danach die Beispielseite der Vorlage (page-examples/dashboard/ in connic-org/connic-awesome-agents) unter demselben Pfad in die Files der Umgebung hoch, setze embed.origins in apps/pages.yaml auf die Adresse der Chat-App, deploye erneut und gib mir den Link zum Chat.
  1. Projekt anlegen. connic init legt aus der Vorlage ein Projekt an, mit ihren Agenten, dem WebSocket-Connector und beiden Apps:

    pip install connic-composer-sdk
    connic init chat-pages --templates=chat-page-builder
    cd chat-pages
  2. Abhängigkeiten der Apps installieren. Deployments installieren sie selbst; connic dev baut die Apps lokal und braucht sie:

    cd apps/chat && npm install
    cd ../pages && npm install
  3. Deployen. Führe connic deploy aus. Apps gehören zu den Tarifen Developer, Pro und Enterprise, und die Vorlage nutzt zwei pro Umgebung.

  4. Beispielseite hochladen. Lege die Dateien aus page-examples/dashboard/ unter demselben Pfad in Files der Umgebung ab.

  5. Chat öffnen. Ersetze den Platzhalter in embed.origins durch die Adresse der Chat-App aus der Apps-Seite, öffne den Chat und frag nach einem Dashboard.

Lass deine Agenten zeigen, was sie gebaut haben

Deploye auf connic einen Chat-Agenten, der Dashboards und Tools baut, die deine Nutzer öffnen, teilen und später wieder aufrufen.

Häufig gestellte Fragen

Ja. Der Agent speichert die Zeilen in einer Collection, und die Seite liest sie über die Data API auf dem eigenen Host der App, nach den Zugriffsregeln der App. Geänderte Zeilen erscheinen beim nächsten Neuladen der Seite, und Seiten können auch speichern, was jemand einträgt.

Alles, was der Basis-Build der App ausliefert. Die Vorlage bringt Tailwind CSS, Chart.js, Lucide-Icons und die Schrift Inter mit. Seiten werden als statische Dateien ohne Build-Schritt veröffentlicht und nutzen deshalb einfache JavaScript-Module. Weitere Browser-Bibliotheken kommen auf dieselbe Weise in den Basis-Build.

Ja. app_publish liefert die Adresse der Seite und, wenn am Agenten ein user gesetzt ist, einen Embed-Link, der als diese Person angemeldet ist. Jede Website, die in den Embed-Origins der App steht, kann die Seite im iframe zeigen, und die Adresse funktioniert auch in einem neuen Tab.

Für die Adresse der Seite gilt die Anmeldung der App, zu der sie gehört. Ein Embed-Link meldet seinen Inhaber als die Person an, für die er erstellt wurde, und öffnet nur diese eine Seite, unabhängig von der Anmeldeart der App.

Bis du sie löschst, in den Details der App im Dashboard oder über connic MCP. Sollen sie automatisch verschwinden, setze max_age_days im apps-Eintrag des Agenten. Seiten werden dann so viele Tage nach ihrer ersten Veröffentlichung gelöscht.