# KI-Tools per MCP mit aclipp verbinden

Verbinde Claude, ChatGPT und Entwickler-Tools mit dem gehosteten aclipp MCP-Server und entdecke alle verfügbaren Tools.

Der aclipp MCP-Server lässt kompatible KI-Clients direkt mit deinen PR-Daten arbeiten. Du kannst Coverage untersuchen, Outlets, Autor:innen und Projektkonfigurationen abrufen und deine KI-Sichtbarkeit analysieren, ohne Daten vorher zu exportieren, und du kannst Projekte samt ihren Wettbewerbern einrichten sowie Coverage anlegen und pflegen, ohne den Client zu verlassen.

Lesen ist der Standard. Schreiben ist optional: Ein Client erhält es nur, wenn er eine Schreibberechtigung wie `clippings:write` oder `prompts:write` anfordert und du sie auf dem Bestätigungsbildschirm freigibst. Beim Löschen eines Prompts wirst du um Bestätigung gebeten. Beim Ersetzen von Report-Blöcken oder Dashboard-Charts werden weggelassene Elemente entfernt.

Alle Clients verbinden sich mit dem gehosteten Endpunkt unter `https://api.aclipp.com/mcp`. Du musst keinen eigenen aclipp Server und keinen lokalen Entwicklungsprozess starten. Es gibt zwei Wege der Authentifizierung:

- **Mit aclipp anmelden (OAuth):** für interaktive Clients wie Claude und ChatGPT. Kein API-Key nötig; du bestätigst die Verbindung im Browser.
- **API-Key:** für Entwickler-Tools wie Claude Code und Cursor oder überall dort, wo du einen langlebigen Zugang bevorzugst.

## Unterstützte Clients

| Client         | Status                     | Authentifizierung                   |
| -------------- | -------------------------- | ----------------------------------- |
| Claude (Web)   | Verfügbar                  | Mit aclipp anmelden                 |
| Claude Desktop | Verfügbar                  | Mit aclipp anmelden                 |
| ChatGPT        | Verfügbar (Developer Mode) | Mit aclipp anmelden                 |
| Claude Code    | Verfügbar                  | aclipp API-Key in einem HTTP-Header |
| Cursor         | Verfügbar                  | aclipp API-Key in `mcp.json`        |

## Voraussetzungen

Du brauchst einen aclipp Workspace mit aktiviertem API-Zugriff. Für Claude und ChatGPT genügt dein normaler aclipp Login. Für Claude Code und Cursor brauchst du zusätzlich einen aclipp API-Key mit den Leserechten, die dein KI-Client verwenden soll.

## Mit aclipp anmelden (OAuth)

Wenn du `https://api.aclipp.com/mcp` als Connector hinzufügst, erkennt der Client den aclipp Login-Ablauf automatisch und öffnet deinen Browser. Du meldest dich mit deinem aclipp Account an und bestätigst die Verbindung:

1. **Organisationen wählen:** Gehörst du nur einer Organisation an, wird sie verwendet und es gibt nichts auszuwählen. Gehörst du mehreren an, wähle alle aus, für die diese Verbindung gelten soll, und aktiviere bei Bedarf **Künftige Organisationen einschließen**, damit eine später hinzukommende Organisation ohne neues Verbinden abgedeckt ist. Die Tools nehmen dann eine optionale `organizationId` entgegen; ohne sie arbeitet der Aufruf in deiner Standard-Organisation.
2. **Projekte wählen:** Standardmäßig sind alle Projekte enthalten, auch später erstellte. Schränke die Auswahl ein, wenn der Client nur bestimmte Projekte sehen soll.
3. **Erlauben:** Unter **Berechtigungen anzeigen** siehst du die angeforderten Aktionen je Bereich. Der Client erhält genau diese Berechtigungen; Schreibrechte sind nur enthalten, wenn er sie angefordert hat.

Verbindungen sind persönlich: Sie handeln in deinem Namen und enden, wenn du die Organisation verlässt. Workspace-Admins sehen alle Verbindungen unter [Einstellungen, Entwickler, Verbundene Apps](https://app.aclipp.com/settings/api/connected-apps) und können jede davon sofort trennen.

### Claude (Web)

1. Öffne die Einstellungen, dann Connectors, und wähle "Add custom connector".
2. Trage `https://api.aclipp.com/mcp` als URL ein und bestätige.
3. Klicke auf Verbinden und schließe die aclipp Anmeldung im Browserfenster ab.
4. Aktiviere den aclipp Connector im Tools-Menü eines Chats. Die aclipp Tools sind jetzt verfügbar.

Benutzerdefinierte Connectors erfordern einen bezahlten Claude Plan. Bei Team- und Enterprise-Plänen muss sie gegebenenfalls zuerst ein Admin freischalten.

### Claude Desktop

Claude Desktop verwendet dieselben Connector-Einstellungen wie Claude im Web: Füge `https://api.aclipp.com/mcp` unter Einstellungen, Connectors hinzu und schließe die Anmeldung im Browser ab.

### ChatGPT

ChatGPT verbindet sich über den Developer Mode:

1. Öffne die Einstellungen, dann Apps & Connectors, dann Advanced, und aktiviere den Developer Mode. Dafür ist ein bezahlter Plan nötig; bei Team- und Enterprise-Plänen muss ihn ein Admin erlauben.
2. Erstelle einen Connector mit der MCP-Server-URL `https://api.aclipp.com/mcp` und OAuth als Authentifizierungsmethode.
3. Schließe die aclipp Anmeldung ab und aktiviere den Connector in einem Chat.

ChatGPT speichert beim Freigeben eines Connectors einen Snapshot der Tool-Definitionen. Verbinde den Connector neu, sobald aclipp neue Tools veröffentlicht, damit ChatGPT seine Liste aktualisiert.

## API-Key erstellen

Öffne für Claude Code und Cursor die [API-Einstellungen deines Workspaces](https://app.aclipp.com/settings/api) und erstelle einen Key für deinen KI-Client. Der vollständige Key wird nur einmal angezeigt. Kopiere ihn deshalb, bevor du den Dialog schließt.

Vergib nur die benötigten Scopes:

| Scope                | Freigeschaltete Daten                                                                        |
| -------------------- | -------------------------------------------------------------------------------------------- |
| `projects:read`      | Projekte, Wettbewerber und Projektkonfiguration.                                             |
| `projects:write`     | Projekte und Wettbewerber anlegen; Wettbewerber, Tags und Metriken bearbeiten.               |
| `prompts:read`       | KI-Sichtbarkeits-Prompts und Prompt-Themen.                                                  |
| `prompts:write`      | Prompts erstellen und bearbeiten.                                                            |
| `clippings:read`     | Gefilterte Clipping-Listen und vollständige Clipping-Details.                                |
| `clippings:write`    | Clippings erstellen und bearbeiten.                                                          |
| `outlets:read`       | Outlet-Listen und vollständige Outlet-Details.                                               |
| `outlets:write`      | Outlets erstellen, bearbeiten, löschen.                                                      |
| `authors:read`       | Autor:innen-Listen und vollständige Autor:innen-Profile.                                     |
| `authors:write`      | Autor:innen erstellen, bearbeiten, löschen.                                                  |
| `alerts:read`        | Alert-Konfigurationen und ihre Filter.                                                       |
| `alerts:write`       | Alerts anlegen und aktualisieren. Löschen erfordert einen API-Key.                           |
| `integrations:read`  | Integrationen eines Projekts, ohne ihre API-Keys.                                            |
| `integrations:write` | Integrationen eines Projekts anlegen, ändern und löschen. API-Keys lassen sich nicht setzen. |
| `reports:read`       | Report-Listen und vollständige Report-Details.                                               |
| `reports:write`      | Reports erstellen, bearbeiten und löschen.                                                   |
| `dashboards:read`    | Dashboard-Listen und vollständige Dashboard-Details.                                         |
| `dashboards:write`   | Dashboards erstellen, bearbeiten und löschen.                                                |
| `analytics:read`     | Aggregierte Clipping- und KI-Sichtbarkeitsanalysen.                                          |
| `ai-visibility:read` | KI-Sichtbarkeits-Chats, Metriken, zitierte Domains und URLs.                                 |

Die Scopes bestimmen, welche Tools der Client sieht. Du kannst den Key zusätzlich auf bestimmte Projekte beschränken.

Manche Tools benötigen für ihre Ressource sowohl den Schreib- als auch den Lese-Scope, weil sie den Datensatz für ihre Arbeit lesen. `delete_prompt` benötigt `prompts:write` und `prompts:read`, und die Update- und Replace-Tools für Reports und Dashboards benötigen den Lese-Scope, um die Änderung auf der aktuellen Version des Dokuments aufzusetzen.

`outlets:write` und `authors:write` umfassen Anlegen, Bearbeiten und Löschen, mit API-Key wie auch über „Mit aclipp anmelden“. Beim Löschen gilt weiterhin die eigene Rolle: Editor:innen dürfen nur selbst angelegte Outlets und Autor:innen löschen.

`alerts:write` ist enger gefasst: Alerts anlegen und aktualisieren geht mit API-Key wie auch über „Mit aclipp anmelden“, Löschen dagegen nur mit API-Key. Ein gelöschter Alert hört einfach auf zu senden, und das bemerkt niemand aktiv. Deshalb bleibt das Löschen bei einem Zugang, den jemand selbst eingerichtet hat. Um die Mails reversibel zu stoppen, deaktiviere den Alert stattdessen.

### Claude Code

Führe diesen Befehl im Terminal aus und ersetze den Beispiel-Key durch deinen neuen Key:

```bash
claude mcp add \
  --transport http \
  --scope user \
  --header "Authorization: Bearer aclipp_live_..." \
  aclipp https://api.aclipp.com/mcp
```

Mit dem Scope `user` ist die Verbindung in allen Claude-Code-Projekten auf deinem Computer verfügbar.

Starte Claude Code und gib Folgendes ein:

```text
/mcp
```

Der Server `aclipp` sollte verbunden sein und seine verfügbaren Tools anzeigen. Du kannst die Verbindung auch im Terminal prüfen:

```bash
claude mcp list
```

### Cursor

Öffne die globale MCP-Konfiguration unter `~/.cursor/mcp.json`. Erstelle alternativ `.cursor/mcp.json`, wenn die Verbindung nur in einem Projekt verfügbar sein soll. Füge Folgendes ein:

```json
{
  "mcpServers": {
    "aclipp": {
      "url": "https://api.aclipp.com/mcp",
      "headers": {
        "Authorization": "Bearer aclipp_live_..."
      }
    }
  }
}
```

Ersetze den Beispiel-Key, speichere die Datei und öffne die MCP-Einstellungen in Cursor. Der Server `aclipp` sollte mit den freigegebenen Tools verfügbar sein. Starte Cursor neu oder deaktiviere und aktiviere den Server, wenn die Verbindung nicht sofort hergestellt wird.

Committe niemals eine projektbezogene `.cursor/mcp.json`, die einen API-Key enthält. Nutze für eine persönliche Verbindung bevorzugt die globale Konfiguration.

## Verfügbare MCP-Tools

Der Server registriert nur die Tools, die durch die Scopes der Verbindung freigegeben sind. Das ist der vollständige aktuelle Tool-Katalog:

| Tool                                                   | Funktion                                                                                                                                                                                                                        | Benötigter Scope                          |
| ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |
| `me` — Verbindung prüfen                               | Zeigt Workspace, Berechtigungen und Projektbeschränkungen der aktuellen Verbindung.                                                                                                                                             | `projects:read`                           |
| `list_organizations` — Organisationen auflisten        | Listet die Organisationen auf, in denen diese Verbindung arbeiten darf. Jedes andere Tool nimmt von hier eine optionale `organizationId` entgegen.                                                                              | `projects:read`                           |
| `list_projects` — Projekte auflisten                   | Listet die für die Verbindung sichtbaren Projekte und ihre IDs auf.                                                                                                                                                             | `projects:read`                           |
| `get_project_config` — Projektkonfiguration abrufen    | Gibt die eigene Marke und die Tag-Gruppen eines Projekts zurück und wie viele Wettbewerber, Tags und benutzerdefinierten Metriken es hat.                                                                                       | `projects:read`                           |
| `create_project` — Projekt anlegen                     | Legt ein Projekt an und wählt seine Lizenzen. KI-Sichtbarkeit ist die Lizenz, die Wettbewerber und Prompts benötigen.                                                                                                           | `projects:write`                          |
| `list_competitors` — Wettbewerber auflisten            | Listet die Wettbewerbermarken eines Projekts mit Name, Aliassen und Domains auf, über die sie erkannt werden.                                                                                                                   | `projects:read`                           |
| `list_integrations` — Integrationen auflisten          | Listet die für ein Projekt eingerichteten Datenquellen mit Filtern und Einstellungen auf. API-Keys werden nie angezeigt.                                                                                                        | `integrations:read`                       |
| `get_integration` — Integration abrufen                | Gibt eine Integration eines Projekts zurück.                                                                                                                                                                                    | `integrations:read`                       |
| `create_integration` — Integration anlegen             | Fügt einem Projekt eine Datenquelle wie RSS-Feeds, Google Alerts oder Argus hinzu, mit den Standardwerten der App für alles, was fehlt. Quellen, die einen API-Key brauchen, liefern nichts, bis du ihn in der App hinterlegst. | `integrations:write`                      |
| `update_integration` — Integration ändern              | Ändert die übergebenen Felder einer Integration; eine übergebene Liste ersetzt die gespeicherte.                                                                                                                                | `integrations:write`                      |
| `delete_integration` — Integration löschen             | Löscht eine Integration nach Bestätigung durch die Nutzer:innen. Bereits übernommene Clippings bleiben erhalten.                                                                                                                | `integrations:write`, `integrations:read` |
| `list_tags` — Tags auflisten                           | Listet die Tags eines Projekts mit IDs und Gruppen auf, seitenweise und filterbar nach Name oder Tag-Gruppe.                                                                                                                    | `projects:read`                           |
| `list_custom_metrics` — Metriken auflisten             | Listet die benutzerdefinierten Metriken eines Projekts mit ihren vollständigen Definitionen auf, einschließlich Optionen und Formeln.                                                                                           | `projects:read`                           |
| `create_competitor` — Wettbewerber anlegen             | Fügt einem KI-Sichtbarkeits-Projekt eine oder mehrere Wettbewerbermarken hinzu (bis zu 25 pro Aufruf). Bereits erfasste Antworten und Seiten werden neu ausgewertet, frühere Erwähnungen erscheinen also nach diesem Durchlauf. | `projects:write`                          |
| `update_competitor` — Wettbewerber aktualisieren       | Ändert Name oder Erkennung eines Wettbewerbers. Aliasse und Domains werden als vollständige Listen ersetzt, nicht ergänzt; eine Änderung wertet die Historie des Projekts neu aus.                                              | `projects:write`                          |
| `create_tag` — Tags anlegen                            | Legt einen oder mehrere Tags in einem Projekt an (bis zu 25 pro Aufruf).                                                                                                                                                        | `projects:write`                          |
| `update_tag` — Tag aktualisieren                       | Ändert Name, Beschreibung oder Tag-Gruppe eines bestehenden Tags.                                                                                                                                                               | `projects:write`                          |
| `create_custom_metric` — Metriken anlegen              | Legt eine oder mehrere projektdefinierte Clipping-Metriken an (bis zu 25 pro Aufruf).                                                                                                                                           | `projects:write`                          |
| `update_custom_metric` — Metrik aktualisieren          | Ändert eine bestehende projektdefinierte Clipping-Metrik.                                                                                                                                                                       | `projects:write`                          |
| `list_prompts` — KI-Sichtbarkeits-Prompts auflisten    | Listet beobachtete Prompts mit Standort, Status und Thema auf.                                                                                                                                                                  | `prompts:read`                            |
| `list_prompt_topics` — Prompt-Themen auflisten         | Listet Prompt-Themen zum Filtern und Gruppieren von KI-Sichtbarkeitsdaten auf.                                                                                                                                                  | `prompts:read`                            |
| `create_prompt` — Prompts anlegen                      | Fügt einem Projekt einen oder mehrere KI-Sichtbarkeits-Prompts hinzu (bis zu 25 pro Aufruf). Ergebnisse erscheinen über die folgenden Läufe, nicht sofort.                                                                      | `prompts:write`                           |
| `update_prompt` — Prompt-Einstellungen aktualisieren   | Ändert Standort, Status, Frequenz oder Thema eines Prompts. Die Formulierung bleibt unverändert, damit historische Ergebnisse derselben Frage zugeordnet bleiben.                                                               | `prompts:write`                           |
| `delete_prompt` — Prompt löschen                       | Beendet nach deiner Bestätigung die Abfrage eines Prompts. Erhobene Ergebnisse bleiben erhalten.                                                                                                                                | `prompts:write`, `prompts:read`           |
| `create_prompt_topic` — Prompt-Themen anlegen          | Legt ein oder mehrere Themen zur Gruppierung von Prompts an (bis zu 25 pro Aufruf). Themen-IDs dienen als Filter und als Analytics-Dimension `topic`.                                                                           | `prompts:write`                           |
| `update_prompt_topic` — Prompt-Thema umbenennen        | Benennt ein bestehendes Prompt-Thema um. Die zugeordneten Prompts und die bisher darauf berichtete Historie bleiben unverändert.                                                                                                | `prompts:write`                           |
| `list_clippings` — Clippings auflisten                 | Listet kompakte Clipping-Datensätze, gefiltert über einen booleschen Filterausdruck für Datum, Kanal, Tags, Outlet, Land, Sentiment und mehr.                                                                                   | `clippings:read`                          |
| `get_clipping` — Clipping abrufen                      | Gibt die vollständigen Details eines Clippings zurück.                                                                                                                                                                          | `clippings:read`                          |
| `get_clipping_import` — Clipping-Import abrufen        | Gibt den Status eines mit clip_url hinzugefügten Links zurück: in Bearbeitung, aufgenommen oder abgelehnt mit Begründung.                                                                                                       | `clippings:read`                          |
| `clip_url` — URL clippen                               | Legt Coverage aus einem Link an und lässt die Verarbeitung Titel, Veröffentlichungsdatum, Outlet, Sentiment und Metriken selbst ermitteln. Der bevorzugte Weg, Coverage anzulegen.                                              | `clippings:write`                         |
| `create_clipping` — Clipping anlegen                   | Erfasst Coverage ohne abrufbaren Link, etwa Print oder Rundfunk. Speichert genau die übergebenen Felder und leitet nichts ab.                                                                                                   | `clippings:write`                         |
| `update_clipping` — Clipping aktualisieren             | Ändert Felder eines bestehenden Clippings. Ein nicht existierendes Outlet wird abgelehnt.                                                                                                                                       | `clippings:write`                         |
| `list_reports` — Reports auflisten                     | Listet die Reports eines Projekts oder des gesamten Workspace mit ID, Einstellungen und Freigabe-URL. Ohne Inhaltsblöcke.                                                                                                       | `reports:read`                            |
| `get_report` — Report abrufen                          | Gibt einen Report mit seinen vollständigen, geordneten Inhaltsblöcken zurück.                                                                                                                                                   | `reports:read`                            |
| `create_report` — Reports anlegen                      | Legt einen oder mehrere Reports in einem Projekt an (bis zu 25 pro Aufruf), auf Wunsch direkt mit Inhaltsblöcken. Immer privat.                                                                                                 | `reports:write`                           |
| `update_report` — Report-Einstellungen ändern          | Ändert Name, Farbe, Freigabestufe, Filter oder Sortierung eines Reports. Die Inhaltsblöcke bleiben unberührt.                                                                                                                   | `reports:write`, `reports:read`           |
| `replace_report_blocks` — Report-Blöcke ersetzen       | Setzt den vollständigen, geordneten Inhalt eines Reports. Ersetzt die gesamte Sammlung, weggelassene Blöcke werden entfernt.                                                                                                    | `reports:write`, `reports:read`           |
| `list_dashboards` — Dashboards auflisten               | Listet die Dashboards eines Projekts oder des gesamten Workspace mit ID, Einstellungen und Freigabe-URL. Ohne Charts.                                                                                                           | `dashboards:read`                         |
| `get_dashboard` — Dashboard abrufen                    | Gibt ein Dashboard mit seinen vollständigen, geordneten Charts zurück.                                                                                                                                                          | `dashboards:read`                         |
| `create_dashboard` — Dashboards anlegen                | Legt ein oder mehrere Dashboards in einem Projekt an (bis zu 25 pro Aufruf), auf Wunsch direkt mit Charts. Immer privat.                                                                                                        | `dashboards:write`                        |
| `update_dashboard` — Dashboard-Einstellungen ändern    | Ändert Name, Freigabestufe, Filter, Vergleichszeitraum oder die Filterbarkeit für Betrachtende eines Dashboards. Die Charts bleiben unberührt.                                                                                  | `dashboards:write`, `dashboards:read`     |
| `replace_dashboard_charts` — Charts ersetzen           | Setzt die vollständige, geordnete Chart-Liste eines Dashboards. Ersetzt die gesamte Sammlung, weggelassene Charts werden entfernt.                                                                                              | `dashboards:write`, `dashboards:read`     |
| `list_outlets` — Outlets auflisten                     | Listet Medien-Outlets mit Suche, Kanal, Projekt und Clipping-Anzahl auf.                                                                                                                                                        | `outlets:read`                            |
| `get_outlet` — Outlet abrufen                          | Gibt ein Outlet mit vollständigem kanalspezifischem Profil und Reichweitendaten zurück.                                                                                                                                         | `outlets:read`                            |
| `update_outlet` — Outlet aktualisieren                 | Korrigiert oder ergänzt Name sowie die Reichweiten- und Profilfelder eines Outlets für seinen Kanal. Das Logo lässt sich hier nicht setzen.                                                                                     | `outlets:write`                           |
| `list_alerts` — Alerts auflisten                       | Listet die Alerts eines Projekts mit Filtern, Empfängern, Auslöser und Status.                                                                                                                                                  | `alerts:read`                             |
| `create_alert` — Alerts anlegen                        | Legt ein oder mehrere Alerts in einem Projekt an (bis zu 25 pro Aufruf). Jeder benachrichtigt seine Empfänger per Mail, sobald neue Beiträge zum Filter passen.                                                                 | `alerts:write`                            |
| `update_alert` — Alert aktualisieren                   | Ändert Name, Filter, Empfänger, Auslöser oder Status eines Alerts. Filter und Empfänger werden vollständig ersetzt, nicht zusammengeführt.                                                                                      | `alerts:write`                            |
| `list_authors` — Autor:innen auflisten                 | Listet die Journalist:innen und Creator hinter der Coverage, mit Clipping-Anzahl, Outlets sowie erster und letzter Veröffentlichung.                                                                                            | `authors:read`                            |
| `get_author` — Autor:in abrufen                        | Gibt eine Autorin oder einen Autor mit Profilen, allen Outlets und den jüngsten Clippings zurück.                                                                                                                               | `authors:read`                            |
| `update_author` — Autor:in aktualisieren               | Korrigiert den Namen und ersetzt die manuell gepflegten Profile und Outlet-Zuordnungen.                                                                                                                                         | `authors:write`                           |
| `list_geo_chats` — KI-Sichtbarkeits-Chats auflisten    | Listet KI-Sichtbarkeitsläufe nach Projekt, Zeitraum, Anbieter, Land, Prompt oder Thema auf.                                                                                                                                     | `ai-visibility:read`                      |
| `get_geo_chat` — KI-Sichtbarkeits-Chat abrufen         | Gibt die vollständigen Details eines KI-Sichtbarkeitslaufs zurück.                                                                                                                                                              | `ai-visibility:read`                      |
| `list_geo_search_queries` — Suchanfragen auflisten     | Listet die Web-Suchen auf, die KI-Anbieter beim Beantworten der Prompts eines Projekts ausgeführt haben, mit ihrer Häufigkeit.                                                                                                  | `ai-visibility:read`                      |
| `search_geo_domains` — Quell-Domains durchsuchen       | Durchsucht die von KI-Antworten zitierten Domains, mit Zitierhäufigkeit und den erwähnten Marken.                                                                                                                               | `ai-visibility:read`                      |
| `search_geo_urls` — Quell-URLs durchsuchen             | Durchsucht die von KI-Antworten zitierten Einzelseiten, mit Zitierhäufigkeit und den erwähnten Marken.                                                                                                                          | `ai-visibility:read`                      |
| `get_geo_source` — KI-Sichtbarkeitsquelle abrufen      | Gibt die Details einer zitierten Domain oder URL zurück.                                                                                                                                                                        | `ai-visibility:read`                      |
| `get_analytics_catalog` — Analyse-Katalog abrufen      | Listet die für ein Projekt verfügbaren Metriken, Formen, Dimensionen, Formate und Aggregationen auf.                                                                                                                            | `analytics:read`                          |
| `query_analytics_scalar` — Einzelwert abfragen         | Gibt einen einzelnen Gesamtwert für eine Metrik zurück, optional gegen einen Vergleichszeitraum.                                                                                                                                | `analytics:read`                          |
| `query_analytics_scalars` — Mehrere Werte abfragen     | Gibt mehrere unabhängige Gesamtwerte in einem Aufruf zurück, einen je angeforderter Metrik.                                                                                                                                     | `analytics:read`                          |
| `query_analytics_series` — Zeitreihe abfragen          | Gibt Tageswerte für eine oder mehrere Metriken über einen Zeitraum zurück.                                                                                                                                                      | `analytics:read`                          |
| `query_analytics_breakdown` — Aufschlüsselung abfragen | Schlüsselt eine Metrik nach einer Dimension auf (Marke, Anbieter, Thema, Prompt, Land, Kanal, Outlet, Tag, Sentiment) und sortiert die Gruppen.                                                                                 | `analytics:read`                          |
| `query_analytics_table` — Tabelle abfragen             | Schlüsselt mehrere Metriken nach einer Dimension auf, mit einer Zeile je Gruppe und einer Spalte je Metrik.                                                                                                                     | `analytics:read`                          |

Halte diese Tabelle aktuell, wenn sich MCP-Tools oder ihre benötigten Scopes ändern.

## Erste Analyse starten

Lass den Client zuerst dein Projekt und seine Konfiguration ermitteln:

```text
Nutze aclipp, um meine Projekte aufzulisten. Rufe für das relevante Projekt
die Konfiguration ab und fasse die Berichterstattung dieses Jahres nach Kanal,
Land, Sentiment und Outlet zusammen. Zeige die stärkste Coverage und auffällige
Lücken.
```

Der Client kann Tag-IDs über die Projektkonfiguration auflösen und sollte den Analyse-Katalog für gültige Kombinationen aus Metrik, Form, Dimension und Aggregation verwenden. Zeitreihen, Aufschlüsselungen und Tabellen benötigen einen Zeitraum von höchstens 366 Tagen. Abfragen mit Ergebniszeilen sind begrenzt und teilen dem Client mit, wenn Ergebnisse gekürzt wurden.

Zum Beispiel:

```text
Vergleiche unsere Berichterstattung in Deutschland und Österreich im letzten
Quartal. Gliedere sie nach Kanal und Sentiment, nenne die wichtigsten Outlets
und belege relevante Aussagen mit den zugrunde liegenden Clippings.
```

## Fehlerbehebung

### Verbindung fehlgeschlagen

Prüfe, ob die URL `https://api.aclipp.com/mcp` konfiguriert ist. Führe in Claude Code `claude mcp list` aus. Öffne in Cursor die MCP-Einstellungen und prüfe den Serverstatus.

### Authentifizierung fehlgeschlagen

Trenne bei OAuth-Verbindungen den Connector im Client und verbinde dich neu; die Anmeldung im Browser erstellt eine frische Verbindung. Das ist auch nötig, nachdem ein Admin die Verbindung getrennt hat oder du die Organisation verlassen hast. Erstelle bei API-Keys einen neuen Key, wenn der konfigurierte Key widerrufen, falsch kopiert oder nicht mehr verfügbar ist. aclipp API-Keys haben das Format `aclipp_live_...`, und der Header-Wert muss mit `Bearer ` beginnen.

### Ein Tool fehlt

Tools werden anhand der Scopes der Verbindung registriert, und ein Tool erscheint nur, wenn die Verbindung alle Scopes besitzt, die es benötigt. Manche brauchen mehr als einen: `delete_prompt` liest zusätzlich den Datensatz, um ihn in der Bestätigung zu beschreiben, und die Update- und Replace-Tools für Reports und Dashboards lesen das Dokument, um die Änderung auf dessen aktueller Version aufzusetzen.

OAuth-Verbindungen erhalten die vom Client angeforderten unterstützten Scopes; fordert der Client keine Scopes an, gewährt aclipp alle unterstützten Lese-Scopes und keinen Schreibzugriff. Aktualisiere oder ersetze bei API-Keys den Key mit den benötigten Scopes und verbinde den Server anschließend neu, damit der Client seine Tool-Liste aktualisiert.

Ein Tool kann außerdem erscheinen und trotzdem abgelehnt werden. Tools werden allein anhand der Scopes angeboten, eine OAuth-Verbindung handelt aber mit deiner Rolle im Workspace, und diese Rolle wird bei jedem Aufruf neu geprüft. Eine Editor-Rolle darf zum Beispiel Dashboards anlegen, aber nicht ändern: `update_dashboard` wird angeboten und antwortet dann, dass die Änderung nicht erlaubt ist. API-Keys sind nicht an eine Rolle gebunden.

### Der Client zeigt eine veraltete Tool-Liste

Verbinde den Server `aclipp` neu oder starte eine neue Client-Sitzung. ChatGPT speichert beim Freigeben eines Connectors einen Snapshot der Tool-Definitionen; verbinde ihn dort ebenfalls neu.

### Verbindung entfernen

Trenne bei Claude und ChatGPT den Connector in den Einstellungen des Clients. Workspace-Admins können jede OAuth-Verbindung zusätzlich unter [Einstellungen, Entwickler, Verbundene Apps](https://app.aclipp.com/settings/api/connected-apps) trennen; der Zugriff endet dann innerhalb einer Minute.

Entferne den benutzerweiten Claude-Code-Server mit:

```bash
claude mcp remove aclipp --scope user
```

Entferne bei Cursor den Eintrag `aclipp` aus `mcp.json`. Widerrufe den API-Key in den [API-Einstellungen deines Workspaces](https://app.aclipp.com/settings/api), sobald du ihn nicht mehr benötigst.

## API-Key sicher aufbewahren

Der API-Key wird in der privaten Konfiguration deines Clients gespeichert. Committe ihn niemals und füge ihn nicht in Chats, Issues, Screenshots oder geteilte Terminalausgaben ein. Verwende für jeden Client einen separaten, minimal berechtigten Key, damit du eine Verbindung widerrufen kannst, ohne andere zu beeinflussen.
