---
title: "Assistenten"
description: "Was ein Assistent ist und wie Du in wenigen Schritten Deinen ersten erstellst – einfach erklärt für den Einstieg."
canonical_url: "https://meingpt.com/docs/platform/assistants"
language: de
---

# Assistenten

Ein **Assistent** ist ein KI-Helfer, den Du einmal einrichtest und danach immer wieder für ähnliche Aufgaben nutzt – zum Beispiel „E-Mails im richtigen Ton beantworten", „Angebote zusammenfassen" oder „Texte ins Englische übersetzen".

Statt jedes Mal von vorne zu erklären, was die KI tun soll, gibst Du einem Assistenten **einmal** feste Anweisungen. Danach startest Du einfach einen Chat mit ihm und legst los.

![Übersicht Deiner Assistenten](/images/assistants/assistants-neu-overview-de.png)

### Assistent oder Workflow?

Ein Assistent ist flexibel – Du chattest frei mit ihm. Ein [Workflow](/docs/platform/workflows-create) folgt festen Schritten. Faustregel: Immer die gleiche Abfolge? → Workflow. Freies Fragen und Antworten? → Assistent.

## In 5 Schritten zu Deinem ersten Assistenten
Du findest Assistenten links in der Navigation unter **Assistenten**. Klicke oben rechts auf **+ Assistent erstellen** – dann öffnet sich das Bearbeitungsfenster. Keine Sorge: Du musst nicht alles ausfüllen. Nur die ersten drei Schritte sind wirklich nötig.

![Das Bearbeitungsfenster eines Assistenten](/images/assistants/assistants-neu-editor-de.png)

**Gib ihm einen Namen und eine kurze Beschreibung**

Im Bereich **Allgemein** legst Du einen Namen und ein Symbol (Avatar) fest, damit Du den Assistenten später schnell wiedererkennst. Die Beschreibung hilft Dir – und Kolleg*innen, mit denen Du ihn teilst – zu verstehen, wofür er gedacht ist.

![Name, Modell, Beschreibung und Projekt im Bereich Allgemein](/images/assistants/assistants-neu-general-de.png)

**Wähle ein Modell (und optional ein Projekt)**

Das Modell ist das „Gehirn" Deines Assistenten. Wenn Du unsicher bist, lass die Einstellung **Bestes Modell** aktiv – sie wählt standardmäßig GPT-5 und wechselt nur bei sehr langen Unterhaltungen (inkl. Anhängen) automatisch zu Gemini 2.5 Flash. Die Auswahl richtet sich nach der Eingabelänge, nicht nach Aufgabentyp – für genauigkeitskritische Aufgaben wähle bewusst ein bestimmtes Modell manuell aus, mehr dazu unter [KI-Modelle](/docs/platform/models).

Unter **Standardprojekt** kannst Du den Assistenten zusätzlich einem [Projekt](/docs/platform/projects) zuordnen. Neue Chats mit diesem Assistenten nutzen dann automatisch dieses Projekt – praktisch, wenn Du zusammengehörige Unterhaltungen an einem Ort bündeln willst.

**Sag ihm, was er tun soll (Anweisungen)**

Das ist der wichtigste Schritt. Im Feld **Anweisungen** (auch System-Prompt genannt) beschreibst Du in einfachen Worten die Aufgabe des Assistenten: Wer ist er, was soll er tun und wie soll er antworten?

**Tipp für den Anfang:** Schreib einfach so, als würdest Du einer neuen Kollegin die Aufgabe erklären. Zum Beispiel: „Du bist eine freundliche Support-Mitarbeiterin. Beantworte Kundenfragen kurz, höflich und auf Deutsch." Über den **Verbessern**-Button hilft Dir meinGPT, den Prompt zu schärfen.

**Optional: Werkzeuge und Wissen ergänzen**

Braucht Dein Assistent mehr als reines Chatten? Im Bereich **Werkzeuge** aktivierst Du grundlegende Tools (z. B. Web-Recherche, Taschenrechner, Diagramme oder **Memory** für ein Langzeitgedächtnis) und verbindest über **Konnektoren** externe Dienste wie Microsoft 365 oder eigene MCP-Server.

![Werkzeuge und Konnektoren](/images/assistants/assistants-neu-tools-de.png)

Unter **Wissen** gibst Du dem Assistenten Zugriff auf eigene Inhalte: Lade **Dateien** hoch (PDF, DOCX, PPTX, XLSX) oder verbinde einen **Datenpool** als durchsuchbaren Wissensindex. So beantwortet er Fragen auf Basis Deiner eigenen Dokumente. Für den ersten Assistenten kannst Du das getrost überspringen – Memory und Skills schauen wir uns [gleich genauer an](#memory).

![Wissen: Dateien und Datenpools verbinden](/images/assistants/assistants-neu-knowledge-de.png)

**Speichern und ausprobieren**

Klicke oben rechts auf **Speichern**. Dein Assistent erscheint jetzt unter **Meine Assistenten**. Öffne ihn, starte einen Chat und teste, ob er so antwortet, wie Du es Dir vorstellst. Du kannst alle Einstellungen jederzeit anpassen.

## Der Editor im Detail
Für den Anfang brauchst Du das nicht alles. Wenn Du aber mehr Kontrolle möchtest, ist hier jede Sektion des Assistenten-Editors erklärt – klapp einfach auf, was Dich interessiert.

### Allgemein – Avatar, Name, Modell, Beschreibung

Die Grundinformationen Deines Assistenten:

- **Avatar:** das Profilbild. In Seitenleiste und Favoriten siehst Du nur den Avatar – wähl ihn als klares Unterscheidungsmerkmal. Klick darauf, um Farbe und Symbol anzupassen.
- **Name:** kurz und prägnant, sodass die Aufgabe sofort erkennbar ist.
- **Modell:** legt fest, welches KI-Modell im Chat genutzt wird. Standard ist **Bestes Modell** – das wählt GPT-5 und wechselt nur bei Kontextfenster-Überschreitung zu Gemini 2.5 Flash, unabhängig vom Aufgabentyp. Für genauigkeitskritische Aufgaben wähle stattdessen bewusst ein Modell manuell aus. Mehr unter [KI-Modelle](/docs/platform/models).
- **Beschreibung:** erläutert Aufgabe und Funktion – ausführlicher als der Name, auch für Kolleg*innen verständlich.
- **Standardprojekt:** ordnet den Assistenten optional einem [Projekt](/docs/platform/projects) zu; neue Chats nutzen dann automatisch dieses Projekt.

### Anweisungen – der System-Prompt

Die Sektion **Anweisungen** ist Deine Hauptstellschraube für das Verhalten des Assistenten. Hier formulierst Du den **System-Prompt** – das Herzstück Deines Assistenten. Ein guter System-Prompt enthält:

- Die **Persona** (Rolle des Assistenten)
- Die **Aufgabe** und wie sie gelöst werden soll
- Weiteren **Kontext**
- Das **Antwortformat**

**Best Practice – mit `##`-Sektionen strukturieren.** Ein Prompt mit klar getrennten Sektionen liefert spürbar bessere Ergebnisse als ein Fließtext:

```text
## Rolle
Du bist Experte für Vertragsanalyse.

## Aufgabe
Analysiere hochgeladene Verträge und identifiziere Risiken.

## Regeln
- Antworte immer auf Deutsch
- Verwende den Datenpool für Referenzdokumente
- Nutze das Charts-Tool für visuelle Darstellungen
```

**System-Prompts werden in dieser Reihenfolge zusammengeführt:**

1. **Globaler Prompt** (Workspace-Ebene, vom Admin gepflegt – Tone of Voice, Unternehmens-Grundsätze)
2. **Assistent-Prompt** (diese Konfiguration – Rolle und Aufgabe des konkreten Assistenten)
3. **Nutzer-Eingabe** im Chat (die konkrete Anfrage)

Halte jede Ebene fokussiert – Doppelungen führen zu unscharfen Antworten.

**Tools im Prompt explizit erwähnen:** Ein aktiviertes Tool wird oft ignoriert, wenn es im System-Prompt nicht erwähnt ist. Verweise konkret darauf, z. B.: *„Verwende das Charts-Tool, um Daten visuell darzustellen, wenn der Nutzer nach Diagrammen fragt."*

Der System-Prompt kennt keine Platzhalter oder Variablen (z. B. für den Namen der angemeldeten Person) – er wird unverändert an das Modell übergeben. Soll der Assistent auf den Namen oder die Rolle des Nutzers eingehen, formuliere das direkt im Prompt oder gib es im Chat mit. Die geschweiften Klammern `{{...}}` aus der [Prompt-Bibliothek](/docs/platform/prompt-library) sind ein anderes, unabhängiges Feature: Sie gelten nur für gespeicherte Prompts und müssen bei jeder Nutzung manuell ausgefüllt werden – auch sie füllen sich nicht automatisch mit Nutzerdaten.

Oben rechts hilft der Button **Verbessern**, den Prompt automatisch zu optimieren (Struktur, Formulierung, Vollständigkeit); **Tipps** öffnet kontextspezifische Hinweise.

### Werkzeuge – Tools, Konnektoren, MCP, Datenbanken

Hier stattest Du den Assistenten mit Fähigkeiten aus, die über reines Antworten hinausgehen. Fünf Bereiche:

- **Grundlegende Tools:** eingebaut und sofort einsatzbereit – Taschenrechner, Charts, Memory, Code-Sandbox, Web-Suche, Übersetzer, Bildgenerator u. a.
- **Konnektoren (Live):** Live-API-Anbindung an externe Dienste (Microsoft 365, Google Workspace, Jira, Confluence, HubSpot, Salesforce). Liefern Echtzeitdaten und führen Aktionen aus. Übersicht: [Alle Konnektoren](/docs/integrations/connectors).
- **Custom MCP:** eigene MCP-Server anbinden – für interne Systeme oder Spezial-APIs. Siehe [Custom MCP Server](/docs/integrations/custom-mcp-server).
- **Datenbanken:** direkter Lesezugriff auf strukturierte Datenquellen (PostgreSQL, MySQL, Tabellen). Siehe [Datenbanken anbinden](/docs/integrations/databases-overview).
- **Integration anfragen:** fehlt Dir ein Werkzeug, kannst Du es hier anfragen.

**Retry-Verhalten:** Schlägt ein einzelner Tool-Aufruf fehl, wiederholt der Assistent ihn automatisch – eine rote Markierung bei einem einzelnen Tool-Call ist normal und heißt nicht, dass die Gesamtantwort fehlgeschlagen ist. Jeder Wiederholungsversuch zählt dabei als eigener Schritt gegen das Limit des Assistenten-Modus: Schlägt ein Tool wiederholt fehl – etwa weil ein angebundener Dienst gerade gestört ist –, kann allein dieses eine Tool das gesamte Schritt-Budget aufbrauchen. Die Antwort endet dann mit [„Maximale Anzahl an Agent-Schritten erreicht"](/docs/platform/chat-errors#agent-max-iterations), auch wenn sich das für Dich wie eine Endlosschleife anfühlt – der Assistent bricht spätestens dort zuverlässig ab.

Memory ist eines der Grundlegenden Tools – ausführlich unter [Memory](#memory). Für eigenen Code sind [Skills](#skills) der nächste Schritt.

### Wissen – Dateien und Datenpools

Gibt dem Assistenten Zugriff auf statisches Unternehmenswissen – über zwei Wege:

- **Dateien hochladen:** einzelne Dokumente per Drag & Drop. Geeignet für überschaubare, assistentenspezifische Bestände.
- **Datenpool verbinden (RAG-Suchindex):** größere Wissensmengen über einen vorab indizierten Suchindex, von Admins gepflegt. Anders als Konnektoren liefern Datenpools keine Live-Daten, sondern durchsuchen einen aufbereiteten Bestand.

Für die meisten Teams läuft der Datenpool über die meinGPT Cloud, ohne dass ein eigener Outpost nötig ist – mehr unter [Datenquellen (RAG)](/docs/integrations/data-pools-rag). Ein eigener [Outpost](/docs/integrations/vault) ist nur für On-Premise-Setups nötig, etwa bei besonderen Sicherheitsanforderungen. Unsicher, ob Konnektor oder Datenpool? Siehe [Integrations-Guide](/docs/integrations/data-integration-guide).

**Mehrere oder größere Dateien brauchen Zeit.** Hochgeladene Dateien müssen verarbeitet werden, bevor der Assistent sie nutzen kann – bei mehreren oder größeren Dateien kann das spürbar dauern. Wächst Dein Bestand über eine überschaubare, assistentenspezifische Sammlung hinaus, ist ein **Datenpool** die bessere Wahl: Er ist für große Mengen gebaut und synchronisiert im Hintergrund, ohne dass Du auf den Abschluss warten musst.

**Excel- und CSV-Dateien werden anders behandelt als Word-Dateien.** Hochgeladene Word-Dokumente bezieht der Assistent automatisch in jedes Gespräch ein, sobald sie verarbeitet sind. Excel- und CSV-Dateien liest er dagegen nicht automatisch mit – er muss aktiv entscheiden, in der Datei nachzuschauen. Ist das in den Anweisungen nicht ausdrücklich vorgegeben, kann es passieren, dass die Datei bei der Antwort schlicht übergangen wird. Gib in den Anweisungen konkret an, wann und wofür die Excel- oder CSV-Datei herangezogen werden soll.

**Grenzen beim Datei-Upload:** Pro Assistent sind bis zu 50 Dateien möglich, jede bis zu 50 MB. Unterstützt werden u. a. PDF, DOCX, PPTX und XLSX. Alte Formate wie **.doc**, **.xls** und **.ppt** werden nicht unterstützt – konvertiere sie vorher in .docx, .xlsx bzw. .pptx.

Schlägt ein Upload fehl, zeigt meinGPT eine Fehlermeldung als Toast an; die Datei erscheint danach nicht in der Wissensliste. Prüfe Dateigröße und Format und lade sie erneut hoch. Bleibt der Fehler bestehen, wende Dich mit dem angezeigten Fehlertext an den Support.

### Erweiterte Optionen – Konversationsstarter & Assistenten-Modus

Zwei optionale Stellschrauben ganz unten im Editor:

- **Konversationsstarter:** vordefinierte Startnachrichten, die beim Aufrufen zur Auswahl stehen (z. B. *„Wie ist der aktuelle Aktienkurs von Apple?"*). Über **Weiteren hinzufügen** legst Du beliebig viele an.
- **Assistenten-Modus:** steuert, wie viele Tool-Aufrufe der Assistent pro Antwort höchstens macht. Standard: **bis zu 5 Tool-Aufrufe**. Höhere Werte helfen bei komplexen Aufgaben, kosten aber mehr Zeit und Credits.

![Erweiterte Optionen: Konversationsstarter und Assistenten-Modus](/images/assistants/assistants-neu-advanced-de.png)

### Assistenten-Check

Der **Assistenten-Check** in der rechten Sidebar prüft live, ob die Grundbestandteile gesetzt sind: System-Prompt definiert, Beschreibung hinzugefügt, Tools aktiviert und Wissensquellen verknüpft. Die detaillierte Analyse läuft zusätzlich beim **Speichern**.

![Assistenten-Check in der Sidebar](/images/assistants/assistants-edit-general-assistant-check-de.png)

## Memory und Skills: mehr aus Deinem Assistenten holen

Zwei optionale Funktionen machen aus einem einfachen Assistenten einen echten Helfer. Du kannst beide jederzeit später ergänzen.

### [Memory – Langzeitgedächtnis](#memory)

Dein Assistent merkt sich Infos über Dich über einzelne Chats hinaus – persönlich und nur für Dich.

### [Skills – eigene Fähigkeiten](#skills)

Eigener Code in einer sicheren Sandbox: APIs aufrufen, Dateien erzeugen, Daten verarbeiten.

### Memory

Mit **Memory** merkt sich Dein Assistent Informationen über Dich über einzelne Chats hinaus – z. B. Deine Rolle, Deine Arbeitsweise oder feste Vorlieben. So musst Du wiederkehrenden Kontext nicht jedes Mal neu erklären.

Memory ist **persönlich pro Nutzer**. Deine Erinnerungen sind an Dein Konto gebunden, für andere nicht sichtbar und werden nicht automatisch mit dem Team geteilt. Sie gelten für **alle Deine Assistenten**, bei denen Memory aktiviert ist – was ein Assistent speichert, kann ein anderer mit aktiviertem Memory ebenfalls nutzen.

**Aktivieren:** Memory ist ein Built-in-Tool und funktioniert nur, wenn es im Assistenten eingeschaltet ist. Du aktivierst es im Editor unter **Werkzeuge → Grundlegende Tools**. Ist es nicht aktiviert, speichert und liest der Assistent keine Erinnerungen.

![Memory unter Grundlegende Tools aktivieren](/images/assistants/memory-enable-tool-de.png)

**Wie es funktioniert:** Memory wird nicht automatisch in jeden Chat geladen. Stattdessen **entscheidet das Modell selbst**, wann es das Gedächtnis nutzt:

- Es **durchsucht** Deine Erinnerungen, bevor es eine Frage beantwortet, die von früherem Kontext abhängen könnte.
- Es **speichert** eine neue Erinnerung, wenn eine stabile Vorliebe oder langfristiger Kontext auftaucht.
- Es **aktualisiert** eine bestehende Erinnerung, wenn Du eine frühere Information korrigierst.

Du siehst diese Aktionen direkt im Chat als eigene Tool-Schritte. Die Suche im Gedächtnis arbeitet dabei **semantisch** – sie findet passende Erinnerungen anhand ihrer Bedeutung, nicht nur bei exakter Wortübereinstimmung.

![Memory-Tool-Schritt im Chat](/images/assistants/memory-chat-toolcall-de.png)

**Verwalten:** Deine Erinnerungen verwaltest Du zentral über die **Memory-Seite in den Einstellungen**. Dort kannst Du sie einsehen, durchsuchen, einzeln oder gemeinsam löschen, über **Alle löschen** komplett entfernen oder aus einer anderen KI importieren.

![Memory-Seite in den Einstellungen](/images/assistants/memory-settings-overview-de.png)

Der Assistent kann Erinnerungen **anlegen, durchsuchen, abrufen und aktualisieren** – aber **nicht löschen**. Das Löschen liegt allein bei Dir in den Einstellungen. Der Inhalt einer Erinnerung wird dort nicht bearbeitet; zum Ändern löschst Du sie oder lässt den Assistenten sie im Chat aktualisieren.

### Tool-Funktionen von Memory

Ist Memory aktiviert, stehen dem Assistenten diese Funktionen zur Verfügung:

| Funktion         | Was sie tut                              |
| ---------------- | ---------------------------------------- |
| `memory_add`     | Eine neue Erinnerung speichern           |
| `memory_search`  | Erinnerungen semantisch durchsuchen      |
| `memory_get_all` | Alle gespeicherten Erinnerungen abrufen  |
| `memory_update`  | Eine bestehende Erinnerung aktualisieren |

### Erinnerungen aus einer anderen KI importieren

Hast Du schon mit ChatGPT, Gemini oder Claude gearbeitet, kannst Du deren gespeichertes Wissen über Dich übernehmen. Auf der **Memory-Seite in den Einstellungen** öffnest Du dazu **Importieren**:

**Prompt kopieren:** meinGPT gibt Dir einen fertigen Prompt. Kopiere ihn und füge ihn in ChatGPT, Gemini oder Claude ein.
**Antwort einfügen:** Bring die Antwort der anderen KI zurück und füge sie ein. meinGPT extrahiert die Erinnerungen und sortiert sie nach Kategorien (Profil, Arbeitsweise, Aktuelle Arbeit, Team & Kontakte, Regeln).
**Prüfen und importieren:** Geh die Vorschläge durch, entferne den Haken bei allem, was Du nicht übernehmen willst, und schließe über **Erinnerungen importieren** ab.

Es werden nur die ausgewählten Erinnerungen gespeichert – pro Import bis zu **50 Erinnerungen**.

### Best Practices für Memory

- Speichere **stabile Vorlieben** und **langfristigen Kontext** – nicht flüchtige Einmal-Details.
- Halte Erinnerungen **kurz und eigenständig**, damit sie einzeln nutzbar bleiben.
- Speichere **keine Secrets** oder hochsensiblen Daten (Passwörter, Schlüssel).
- Lass bestehende Erinnerungen bei Korrekturen **aktualisieren**, statt Duplikate anzulegen.

### Skills

**Skills** sind wiederverwendbare Code-Pakete (`.zip`), die Deinem Assistenten Fähigkeiten geben, die über reines Prompting oder Wissen-Anbindung hinausgehen. Sie werden in der **Code-Sandbox** ausgeführt und können externe APIs aufrufen, Dateien generieren, Daten verarbeiten oder spezialisierte Logik anwenden.

Skills sind im Editor eine **eigenständige Sektion direkt unter Wissen** – kein Teil der Werkzeuge-Sektion, auch wenn beide zusammenspielen. Sie stehen nur zur Verfügung, wenn die Code-Sandbox für Deine Organisation aktiv ist (Standard: an). Fehlt der Skills-Bereich, frag eine:n Admin.

**Wann macht ein Skill Sinn?** Wenn Dein Assistent:

- **eine API aufrufen** soll, für die es keinen nativen Connector gibt (z. B. Euer internes Vertragsmanagement-System)
- **eine Datei generieren** soll mit Eurem Layout (Word-Vorlage, Excel-Bericht, PowerPoint mit Branding)
- **Daten verarbeiten** muss in einem Format, das das Modell nativ nicht handhabt (z. B. Binärdaten parsen)
- **deterministische Logik** braucht (Berechnungen, Validierung, Geschäftsregeln)

Reicht ein System-Prompt plus Wissen/Datenpool und native Tools, brauchst Du keinen Skill – Skills sind die nächste Stufe für **eigene ausführbare Logik**.

**So fügst Du einen Skill hinzu:** Der Skills-Bereich liegt im Editor als eigene Karte, mit Button **Skill erstellen** oben rechts und einer Drag-&-Drop-Fläche darunter. Es gibt zwei Wege:

![Skills-Bereich im Assistenten-Editor](/images/assistants/assistants-neu-skills-de.png)

#### Weg 1: Skill per Chat erstellen lassen

Ein Klick auf **Skill erstellen** öffnet keinen Wizard, sondern einen ganz normalen neuen Chat mit Deinem Assistenten – mit einer vorausgefüllten ersten Nachricht: *„Erstelle mir einen neuen Skill für diesen Assistenten."*

![Der Button „Skill erstellen" im Skills-Bereich](/images/skills/skills-create-chat-1-de.png)

**Nachricht abschicken:** Die vorausgefüllte Nachricht ist schon im Eingabefeld – einfach senden.
**Rückfragen beantworten:** Der Assistent interviewt Dich, bevor er Code schreibt – Zweck des Skills, benötigte APIs, Zugangsdaten und ob eine bestehende Datei als Grundlage dienen soll.
**Code wird generiert:** Der Assistent schreibt die Dateien des Pakets (mindestens eine `SKILL.md`) und baut daraus ein `.zip`.
**Automatisch angehängt:** Das fertige Paket erscheint direkt in der Skills-Liste – kein manueller Upload nötig.

![Rückfragen des Assistenten nach dem Absenden](/images/skills/skills-create-chat-2-de.png)

Enthält der Skill Zugangsdaten (API-Keys, Tokens), legt der Assistent dafür eine `secrets.json` mit Platzhaltern an. Die echten Werte trägst Du danach im Datei-Explorer ein – sie werden nicht im Chat abgefragt oder protokolliert.

#### Weg 2: Fertiges `.zip` hochladen

Liegt der Skill schon als Paket vor, zieh die `.zip`-Datei in die Drag-&-Drop-Fläche oder klick zum Auswählen.

![Fertiges .zip-Paket per Drag & Drop hochladen](/images/skills/skills-upload-dropzone-de.png)

- **Grenzen:** bis zu 20 Dateien gleichzeitig, praktisches Limit **50 MB pro Datei**.
- **Keine Struktur-Prüfung:** Die Plattform prüft nur auf technische Sicherheit (kein Zip-Bomb). Ob eine `SKILL.md` enthalten oder sinnvoll aufgebaut ist, wird **nicht** validiert – halte Dich an die empfohlene Struktur unten.

### Skill vs. Tool vs. Connector – kurze Abgrenzung

| Werkzeug | Was es ist | Wann |
|---|---|---|
| **Native Tool / Connector** | Vorgefertigte Anbindung an Standard-Dienste (Slack, Outlook, Salesforce …) | Standard-Integrationen aus dem Marketplace |
| **Skill** (`.zip`) | Eigener Code (Python oder JS/TS), der in der Sandbox läuft | Custom-Logik, proprietäre APIs, Datei-Generierung im eigenen Format |
| **Wissen / Datenpool** | RAG über statische Dokumente | Wenn der Assistent Euer Wissen kennen, nicht ausführen soll |

### Aufbau eines Skill-Pakets

Ein Skill-Paket ist ein `.zip` mit einer `SKILL.md` als Anleitung plus dem Code. Empfohlene Struktur:

```
mein-skill/
├── SKILL.md
├── scripts/
│   ├── main.py
│   └── helpers.py
└── references/
    └── api-reference.md
```

Die `SKILL.md` beginnt mit einem YAML-Frontmatter und ist danach freies Markdown:

| Feld / Abschnitt | Zweck |
|---|---|
| `name` | Kurzer, sprechender Name (klein, mit Bindestrichen) |
| `description` | Wann der Assistent den Skill einsetzen soll – daran orientiert sich das Modell |
| `license` (optional) | Meist `Proprietary` oder `MIT` |
| Titel (H1) | Ein-Satz-Zusammenfassung |
| `## Rules` | Was der Assistent tun/lassen soll |
| `## Workflow` | Schritt-für-Schritt-Ablauf |
| `## Good fits` | Konkrete Anwendungsfälle |
| `## Avoid by default` | Wofür der Skill **nicht** gedacht ist |

Wird die `SKILL.md` zu lang (Richtwert 500 Zeilen), lagere Details nach `references/` aus. Die Sprache (Python oder JavaScript) wird automatisch erkannt – anhand von Markern wie `requirements.txt` (Python) oder `package.json` (JS). Fehlt ein Marker, greift JavaScript. Nimm bei einem Python-Skill also eine `requirements.txt` auf, auch wenn sie leer bleibt.

### Sicherheit & Sandbox

Skills laufen in einer isolierten Sandbox:

- Kein direkter Zugriff aufs Host-System, kein Internet-Zugriff aus dem Skill-Code
- Sprache pro Skill wird beim Einbinden automatisch erkannt (Python oder JS)
- Zugangsdaten liegen als `secrets.json` im Paket und werden nicht an das Modell ausgeliefert
- Ressourcen-Limits verhindern Endlos-Schleifen oder übermäßigen Speicherverbrauch

Details unter [Code-Sandbox](/docs/platform/code-sandbox).

### Häufige Verwendungen

| Use-Case | Skill-Inhalt |
|---|---|
| Angebote im Firmen-Layout generieren | Word-Vorlage + Python-Skript, das Chat-Daten einsetzt |
| DATEV-Export aus Rechnungs-Daten | JS-Skript, das JSON in CSV konvertiert |
| Anbindung ans interne CRM (kein Standard-Connector) | Python-API-Client für Euer CRM |
| Strukturierte PDF-Extraktion aus eigenem Layout | Python mit `pdfplumber` |
| Custom-Validierung (z. B. Steuer-Berechnungen) | JS mit Eurer Berechnungslogik |

**Formatierungstreue ist keine Garantie.** Beim Befüllen einer Word-Vorlage übernimmt der Skill deren vorhandene Styles – eine exakte Übereinstimmung mit Deinen Brand Guidelines wird nicht automatisch geprüft. Bei markenkritischen Vorlagen das Ergebnis stichprobenartig kontrollieren.

### Bearbeiten & Grenzen

Ein Klick auf einen Skill in der Liste öffnet den Datei-Explorer: Dateibaum links (`SKILL.md` ganz oben), Code-Editor rechts. Du kannst Dateien einsehen, bearbeiten, löschen und zurück ins Paket speichern.

![Skill-Datei-Explorer](/images/skills/skills-file-explorer-de.png)

- **Keine Versionshistorie:** Speichern überschreibt den bisherigen Stand endgültig – sichere Dir vor größeren Änderungen eine eigene Kopie.
- **Kein Teilen zwischen Assistenten:** Jeder Skill gehört genau einem Assistenten. Für mehrere Assistenten lade die `.zip` bei jedem einzeln hoch.
- **„Verbessern" legt oft ein neues Paket an:** Bittest Du den Assistenten, einen bestehenden Skill zu erweitern, erzeugt er häufig ein neues Paket – entferne veraltete Duplikate manuell.

## Assistenten verwenden
Ist Dein Assistent gespeichert, kannst Du ihn nutzen, teilen und verwalten.

### Chat starten

Es gibt mehrere Wege:

- Klick auf das Profilbild unter **Favoriten**.
- Direkt aus der **Vorschau** oben rechts auf der Bearbeitungsseite.
- Unter **Meine Assistenten** auswählen und mit einem Konversationsstarter oder eigener Nachricht beginnen.
- In einem allgemeinen Chat über die **Modellauswahl** unten rechts einen Assistenten wählen.

Ein Klick auf die Karte unter **Meine Assistenten** startet direkt einen Chat – die häufigste Aktion.

### Assistenten bearbeiten

Da ein Assistent öfter verwendet als bearbeitet wird, ist der Klick auf die Karte für den Chat-Start reserviert. Die Konfiguration erreichst Du über das **Drei-Punkte-Menü (⋮)** auf der Karte → **Assistent Bearbeiten**. Das Menü erscheint nur mit Bearbeitungsrechten; bei **Kann nutzen** geteilten Assistenten steht es nicht zur Verfügung.

### Favorisieren

Klick auf den **Stern** auf der Karte. Favorisierte Assistenten erscheinen im Bereich **Favoriten** der Seitenleiste mit ihrem Avatar – der Chat ist per Klick startbar.

![Favorisierte Assistenten in der Sidebar](/images/assistants/assistants-sidebar-favorites-de.png)

### Teilen

In zwei Schritten: Klick auf das **Teilen-Symbol** (auf der Karte oder im Editor oben rechts), dann Personen oder Teams suchen und die Zugriffsart wählen:

- **Kann nutzen** – verwenden, aber Konfiguration nicht einsehen/bearbeiten
- **Kann ansehen** – ansehen, aber nicht verwenden/bearbeiten
- **Kann bearbeiten** – verwenden, verändern und Freigaben verwalten

Workspace-Admins können auch für **Alle im Workspace** freigeben (organisationsweit nur **Kann nutzen** oder **Kann ansehen**). Der Dialog zeigt alle aktiven Freigaben; das Entfernen der workspaceweiten Freigabe muss bestätigt werden.

![Teilen-Dialog mit Berechtigungen](/images/assistants/assistants-share-assistant-context-de.png)

### Per Link importieren

Assistenten lassen sich über einen teilbaren Import-Link hinzufügen. Links erstellst Du mit dem [Assistant Creator](https://assistant-creator.meingpt.com/). Die Import-Seite unterstützt die Parameter `c` (komprimiert, empfohlen) und `p` (legacy). Details: [Assistant Creator](/docs/admin-guide/assistant-creator).

### An die Seitenleiste anheften (Admins)

Workspace-Admins können freigegebene Assistenten an den **Apps-Bereich** der Seitenleiste anheften – sie erscheinen dort dann als eigenständige Chatbot-Apps. Anheften über das **Anheften-Symbol (📌)** in der Kopfzeile der Karte oder in der Editor-Werkzeugleiste; Lösen über dasselbe Symbol oder das Kontextmenü. Angeheftete Assistenten sind weiterhin nur für Personen sichtbar, die ohnehin Zugriff auf sie haben – die normalen Berechtigungsprüfungen gelten unverändert. Angeheftete Assistenten können erst nach dem Lösen gelöscht werden.

### Löschen

Über das **Drei-Punkte-Menü (⋮)** auf der Karte findest Du **Löschen**. Ein Bestätigungsdialog fragt vor dem endgültigen Entfernen noch einmal nach.

Ist der Assistent an die Seitenleiste angeheftet, ist der Eintrag **Löschen** deaktiviert – löse ihn zuerst über **Von der Seitenleiste lösen** (siehe oben), erst danach lässt er sich löschen.

Eine Freigabe (an Personen, Teams oder den ganzen Workspace) schränkt das Löschen für Dich als Eigentümer:in nicht ein.

### Mehrsprachigkeit

Denselben Assistenten kannst Du für internationale Teams mehrsprachig anbieten, ohne ihn zu duplizieren: Beschreibung, System-Prompt und Konversationsstarter lassen sich übersetzt hinterlegen. Beim Aufrufen wird die Variante in der Sprache des Workspaces bzw. der Nutzer*in angezeigt.

### Per API ansprechen

Über die meinGPT-API rufst Du Assistenten aus eigenen Anwendungen oder Automatisierungen auf (z. B. Make). Die **AssistantID** steht in der Browser-URL im Bearbeitungsmodus nach `/assistants/` (z. B. `.../assistants/abc-123` → ID `abc-123`). Vollständige Referenz: [Assistenten-API](/docs/api/assistants).

## Wenn Du tiefer einsteigen möchtest

### [KI-Modelle](/docs/platform/models)

Die verfügbaren Modelle und wann welches passt

### [Konnektoren](/docs/integrations/connectors)

Externe Dienste wie Microsoft 365, Jira oder Salesforce anbinden

### [Code-Sandbox](/docs/platform/code-sandbox)

Wie die Ausführungs-Umgebung für Skills im Detail funktioniert