> ## Documentation Index
> Fetch the complete documentation index at: https://docs.windsurf.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Memories & Regeln

> Kontext über Cascade-Gespräche hinweg beibehalten – mit automatisch generierten Memories und benutzerdefinierten Regeln auf globaler Ebene, Workspace-Ebene und Systemebene für Enterprise-Teams.

`Memories` ist das System zum Teilen und dauerhaften Speichern von Kontext über Gespräche hinweg.

In Windsurf gibt es dafür zwei Mechanismen: **Memories**, die automatisch von Cascade erzeugt werden, und **Regeln**, die vom Benutzer auf globaler Ebene, Workspace-Ebene oder Systemebene manuell definiert werden.

<div id="memories-rules-workflows-or-skills">
  ## Memories, Regeln, Workflows oder Skills?
</div>

Windsurf bietet mehrere Möglichkeiten, Cascade anzupassen. Verwenden Sie diese Tabelle, um die richtige Option auszuwählen:

| Feature                                         | Was es macht                                                                      | Wie es aktiviert wird                                                                  | Wann Sie es verwenden sollten                                                                                    |
| ----------------------------------------------- | --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| **[Rules](#rules)**                             | Geben Cascade vor, *wie es sich verhalten soll* (z. B. „bun statt npm verwenden“) | `always_on`, `glob`, `model_decision` oder `manual` ([siehe unten](#activation-modes)) | Coding-Konventionen, Styleguides, Projektvorgaben                                                                |
| **[AGENTS.md](/de/windsurf/cascade/agents-md)** | Verzeichnisbezogene Regeln ohne Konfigurationsaufwand                             | Automatisch — root = immer aktiv, Unterverzeichnis = glob                              | Verzeichnisspezifische Konventionen ohne Frontmatter                                                             |
| **[Workflows](/de/windsurf/cascade/workflows)** | Prompt-Vorlagen für wiederkehrende mehrstufige Aufgaben                           | **Nur manuell** über den Slash-Befehl `/[workflow-name]`                               | Deployments, PR-Reviews, Release-Checklisten                                                                     |
| **[Skills](/de/windsurf/cascade/skills)**       | Mehrstufige Abläufe, gebündelt mit unterstützenden Dateien (Skripte, Vorlagen)    | Dynamisch durch das Modell aufgerufen oder per `@mention`                              | Komplexe Aufgaben, bei denen Cascade Referenzdateien benötigt — **hier lohnt es sich, Zeit zu investieren**      |
| **[Memories](#memories)**                       | Kontext, den Cascade während Unterhaltungen automatisch generiert                 | Automatischer Abruf, wenn relevant                                                     | Lassen Sie Cascade einmalige Fakten speichern; für dauerhaftes Wissen sind Regeln oder AGENTS.md besser geeignet |

<Tip>
  **Empfehlung:** Für Wissen, das Cascade zuverlässig wiederverwenden soll, schreiben Sie es als Regel oder fügen Sie es in Ihrem Repository zu `AGENTS.md` hinzu, statt sich auf automatisch generierte Memories zu verlassen. Regeln sind versionskontrolliert, mit Ihrem Team teilbar und geben Ihnen explizite Kontrolle über die Aktivierung.
</Tip>

<div id="how-to-manage-memories">
  ## So verwalten Sie Memories
</div>

Auf Memories und Rules können Sie jederzeit zugreifen und sie konfigurieren, indem Sie im Schiebemenü oben rechts in Cascade auf das Symbol `Customizations` klicken oder über „Windsurf – Settings“ in der rechten unteren Ecke. Um eine bestehende Memory zu bearbeiten, klicken Sie einfach darauf und anschließend auf die Schaltfläche `Edit`.

<video autoPlay controls muted loop playsInline className="aspect-video" src="https://mintcdn.com/codeium/qJj_RRojefb93yIg/assets/windsurf/cascade/memories-rules.mp4?fit=max&auto=format&n=qJj_RRojefb93yIg&q=85&s=2a80ad4bb69460c082c09f9633ab3649" data-path="assets/windsurf/cascade/memories-rules.mp4" />

<div id="memories">
  ## Memorys
</div>

Während eines Gesprächs kann Cascade automatisch Memorys generieren und speichern, wenn es auf Kontext stößt, den es für nützlich hält, um ihn sich zu merken.

Außerdem kannst du Cascade jederzeit bitten, ein Memory zu erstellen. Bitte Cascade einfach: „Erstelle ein Memory von ...“.

Die automatisch generierten Memorys von Cascade sind dem Workspace zugeordnet, in dem sie erstellt wurden, und werden lokal in `~/.codeium/windsurf/memories/` gespeichert. Cascade ruft sie ab, wenn es sie für relevant hält. In einem Workspace generierte Memorys sind in einem anderen nicht verfügbar, und sie werden nicht in dein Repository übernommen.

<Tip>Das Erstellen und Verwenden automatisch generierter Memorys verbraucht KEINE Credits.</Tip>

<Note>
  Automatisch generierte Memorys befinden sich nur auf deinem Rechner. Wenn du möchtest, dass Cascade sich dauerhaft an etwas erinnert — und es mit deinem Team teilt — bitte Cascade stattdessen, es in eine [Regel](#rules) in `.windsurf/rules/` oder in die `AGENTS.md` deines Repos zu schreiben.
</Note>

<div id="rules">
  ## Regeln
</div>

Benutzer können explizit eigene Regeln festlegen, die Cascade befolgen soll.

Regeln können auf globaler, Workspace- oder Systemebene definiert werden und auch aus [AGENTS.md](/de/windsurf/cascade/agents-md)-Dateien abgeleitet werden.

| Geltungsbereich                                       | Speicherort                                           | Hinweise                                                                                                                                 |
| ----------------------------------------------------- | ----------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| Global                                                | `~/.codeium/windsurf/memories/global_rules.md`        | Eine einzelne Datei, die für alle Workspaces gilt. Immer aktiv. Auf 6.000 Zeichen begrenzt.                                              |
| Workspace                                             | `.windsurf/rules/*.md`                                | Eine Datei pro Regel, jeweils mit eigenem [Aktivierungsmodus](#activation-modes). Auf 12.000 Zeichen pro Datei begrenzt.                 |
| [AGENTS.md](/de/windsurf/cascade/agents-md)           | Beliebiges Verzeichnis in Ihrem Workspace             | Wird von derselben Regel-Engine verarbeitet — im Stammverzeichnis = immer aktiv, im Unterverzeichnis = Auto-Glob für dieses Verzeichnis. |
| [System (Enterprise)](#system-level-rules-enterprise) | Betriebssystemabhängig (z. B. `/etc/windsurf/rules/`) | Von der IT bereitgestellt, für Endbenutzer schreibgeschützt.                                                                             |

<div id="rules-discovery">
  ## Regelermittlung
</div>

Windsurf erkennt Regeln automatisch aus mehreren Quellen, um eine flexible Organisation zu ermöglichen:

* **Aktueller Workspace und Unterverzeichnisse**: Alle `.windsurf/rules`-Verzeichnisse innerhalb Ihres aktuellen Workspaces und seiner Unterverzeichnisse
* **Git-Repository-Struktur**: Für Git-Repositories durchsucht Windsurf zusätzlich bis zum Git-Root-Verzeichnis, um Regeln in übergeordneten Verzeichnissen zu finden
* **Unterstützung mehrerer Workspaces**: Wenn mehrere Ordner im selben Workspace geöffnet sind, werden Regeln dedupliziert und mit dem kürzesten relativen Pfad angezeigt

<div id="rules-storage-locations">
  ### Speicherorte für Regeln
</div>

Regeln können an folgenden Orten gespeichert werden:

* `.windsurf/rules` in Ihrem aktuellen Workspace-Verzeichnis
* `.windsurf/rules` in jedem Unterverzeichnis Ihres Workspaces
* `.windsurf/rules` in übergeordneten Verzeichnissen bis zum Git-Root (für Git-Repositories)

Wenn Sie eine neue Regel erstellen, wird sie im Verzeichnis `.windsurf/rules` Ihres aktuellen Workspaces gespeichert, nicht unbedingt im Git-Root.

Um mit Regeln zu starten, klicken Sie im Schiebemenü oben rechts in Cascade auf das Symbol `Customizations` und navigieren Sie anschließend zum Panel `Rules`. Dort können Sie auf die Schaltfläche `+ Global` oder `+ Workspace` klicken, um neue Regeln entweder auf globaler Ebene oder auf Workspace-Ebene zu erstellen.

<Tip>Beispielvorlagen für Regeln, kuratiert vom Windsurf-Team, finden Sie unter [https://windsurf.com/editor/directory](https://windsurf.com/editor/directory), um den Einstieg zu erleichtern.</Tip>

Workspace-Regeldateien sind jeweils auf 12.000 Zeichen begrenzt. Die globale Regeldatei ist auf 6.000 Zeichen begrenzt.

<div id="activation-modes">
  ### Aktivierungsmodi
</div>

Jede Workspace-Regel legt in ihrem Frontmatter über das Feld `trigger` einen Aktivierungsmodus fest. Dieser steuert, **wann** der Inhalt der Regel an Cascade übergeben wird und **wie viel Platz er im Kontextfenster belegt**:

| Modus                  | `trigger:`-Wert  | So gelangt sie zu Cascade                                                                                                                                  | Kontextkosten                                       |
| ---------------------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
| **Immer aktiv**        | `always_on`      | Der vollständige Regelinhalt wird bei jeder Nachricht in den System-Prompt aufgenommen.                                                                    | Bei jeder Nachricht                                 |
| **Modellentscheidung** | `model_decision` | Nur die `description` wird im System-Prompt angezeigt. Cascade liest die vollständige Regeldatei, wenn es entscheidet, dass die Beschreibung relevant ist. | Beschreibung immer; vollständiger Inhalt bei Bedarf |
| **Glob**               | `glob`           | Die Regel wird angewendet, wenn Cascade eine Datei liest oder bearbeitet, die dem `globs`-Muster entspricht (z. B. `*.js`, `src/**/*.ts`).                 | Nur wenn passende Dateien betroffen sind            |
| **Manuell**            | `manual`         | Die Regel ist **nicht** im System-Prompt. Du aktivierst sie, indem du `@rule-name` in das Cascade-Eingabefeld eingibst.                                    | Nur bei @Erwähnung                                  |

<Note>
  Die globale Regeldatei (`global_rules.md`) und `AGENTS.md`-Dateien im Root-Verzeichnis verwenden kein Frontmatter — sie sind immer aktiv.
</Note>

Beispiel für eine Workspace-Regel mit Frontmatter:

```markdown theme={null}
---
trigger: glob
globs: **/*.test.ts
---

Alle Testdateien müssen `describe`/`it`-Blöcke verwenden und externe API-Aufrufe mocken.
```

<div id="best-practices">
  ### Best Practices
</div>

Damit Cascade Ihren Regeln effektiv folgen kann, beachten Sie diese Best Practices:

* Halten Sie Regeln einfach, prägnant und konkret. Zu lange oder vage Regeln können Cascade verwirren.
* Fügen Sie keine generischen Regeln hinzu (z. B. „schreibe guten Code“), da diese bereits in Cascades Trainingsdaten enthalten sind.
* Formatieren Sie Ihre Regeln mit Aufzählungspunkten, nummerierten Listen und Markdown. Das ist für Cascade einfacher zu befolgen als ein langer Fließtext. Zum Beispiel:

```
# Coding-Richtlinien 
- Die Programmiersprache meines Projekts ist Python
- Verwende Early Returns, wenn möglich
- Füge immer Dokumentation hinzu, wenn du neue Funktionen und Klassen erstellst
```

* XML-Tags können eine effektive Möglichkeit sein, um Informationen zu vermitteln und ähnliche Regeln zu gruppieren. Zum Beispiel:

```
<coding_guidelines>
- Die Programmiersprache meines Projekts ist Python
- Verwende frühe Rückgaben, wenn möglich
- Füge immer Dokumentation hinzu, wenn du neue Funktionen und Klassen erstellst
</coding_guidelines>
```

<div id="system-level-rules-enterprise">
  ## System-Level Rules (Enterprise)
</div>

Enterprise-Organisationen können System-Level Rules bereitstellen, die global für alle Workspaces gelten und von Endbenutzern ohne Administratorrechte nicht geändert werden können. Dies ist ideal, um organisationsweite Coding-Standards, Sicherheitsrichtlinien und Compliance-Vorgaben durchzusetzen.

System-Level Rules werden aus betriebssystemspezifischen Verzeichnissen geladen:

**macOS:**

```
/Library/Application Support/Windsurf/rules/*.md
```

**Linux/WSL:**

```
/etc/windsurf/rules/*.md
```

**Windows:**

```
C:\ProgramData\Windsurf\rules\*.md
```

Legen Sie Ihre Regeldateien (als `.md`-Dateien) in das entsprechende Verzeichnis für Ihr Betriebssystem. Das System lädt automatisch alle `.md`-Dateien aus diesen Verzeichnissen.

<div id="how-system-rules-work">
  ### Wie Systemregeln funktionieren
</div>

Systemweite Regeln werden mit Workspace- und globalen Regeln zusammengeführt und stellen zusätzlichen Kontext für Cascade bereit, ohne benutzerdefinierte Regeln zu überschreiben. So können Organisationen grundlegende Standards festlegen und Teams gleichzeitig erlauben, projektspezifische Anpassungen vorzunehmen.

In der Windsurf-Benutzeroberfläche werden systemweite Regeln mit der Kennzeichnung „System“ angezeigt und können von Endbenutzern nicht gelöscht werden.

<Note>
  **Wichtig**: Systemweite Regeln sollten von Ihrem IT- oder Sicherheitsteam verwaltet werden. Stellen Sie sicher, dass Ihre internen Teams Bereitstellung, Updates und Compliance gemäß den Richtlinien Ihrer Organisation durchführen. Sie können dafür Standardtools und -Workflows wie Mobile Device Management (MDM) oder Konfigurationsmanagement verwenden.
</Note>