---
description: "MCP-Server (Model Context Protocol) verbinden Agenten mit externen Tools und Datenquellen."
---

# MCP-Server

MCP-Server (Model Context Protocol) verbinden Agenten mit externen Tools und Datenquellen. Du konfigurierst sie einmal, weist sie Agenten zu, und sie stehen zur Laufzeit zur Verfügung.


## MCP-Server-Konfiguration

### Pro Agent

Jeder Agent hat im Bereich **Agent-Details** einen Tab **MCP-Server**:

- **MCP-Server hinzufügen** — Name, URL, optionale Auth-Header
- **Verbindung testen** — vor dem Speichern prüfen
- **Aktivieren/Deaktivieren** — pro Server und pro Agent umschalten
- **Status** — zeigt den letzten Verbindungsstatus
- **Verbinden (OAuth)** — für Server, bei denen du dich anmelden musst (siehe unten)

### Mit OAuth verbinden

Manche MCP-Server verlangen eine Anmeldung statt eines festen Headers. Dafür gilt:

1. Drücke in der Zeile des Servers auf **Verbinden (OAuth)**. Der Dialog **MCP-Server per OAuth verbinden** erklärt, dass du in diesem Browser-Tab zur Anmeldeseite des Servers weitergeleitet wirst und danach hierher zurückkehrst.
2. Wenn der Anbieter eine vorab registrierte Weiterleitungsadresse braucht, kopiere die im Dialog angezeigte Redirect-URI genau so in die OAuth-App-Einstellungen des Anbieters.
3. Fülle die manuellen Felder (Client-ID, ein optionales Client-Secret und die Endpunkte) nur aus, wenn sich der Server nicht automatisch als Client registrieren oder erkennen lässt. Der Dialog sagt dir, wann eine Client-ID erforderlich ist.
4. Drücke **Fortfahren**, melde dich beim Anbieter an, und du kehrst zum Agenten zurück.

Die Zeile zeigt dann **OAuth · verbunden**, **OAuth · ausstehend** (Anmeldung gestartet, aber nicht abgeschlossen) oder **OAuth · Fehler**. **Neu autorisieren** führt die Anmeldung erneut aus.

Jeder Nutzer verbindet sich **als er selbst**. Die OAuth-App (der Client) wird einmal pro Server eingerichtet und wiederverwendet. Hat ein Kollege den Server bereits verbunden, drückst du nur **Verbinden (OAuth)** und meldest dich an — eine Client-ID ist nicht nötig. Das Token jedes Nutzers wird verschlüsselt gespeichert, gehört diesem Nutzer, wird nie angezeigt und wird den Ausführungen hinzugefügt, **die dieser Nutzer startet**. **Trennen** entfernt nur deine eigene Verbindung; andere Nutzer bleiben verbunden.

Geplante und wiederkehrende Aufgaben haben keinen Nutzer im Hintergrund. Sie verwenden die eine Verbindung, die als **Für unbeaufsichtigte Ausführungen verwenden** markiert ist (setze den Haken im Verbinden-Dialog; sie wechselt zu dir, falls sie jemand anderem gehörte). Hat der Starter einer Ausführung keine Verbindung und ist keine für unbeaufsichtigte Ausführungen markiert, startet die Ausführung trotzdem — ohne das Token — und weist im Log darauf hin.

Um den Server auf eine andere OAuth-App umzustellen, öffne im Dialog **Andere OAuth-App verwenden**. Das ersetzt die App für alle, und die Verbindungen der anderen Nutzer zeigen dann **OAuth · Fehler**, bis sie sich neu verbinden.

### Global (System-Administrator)

Der Tab **AO MCP** unter **Globale Einstellungen** zeigt den eingebauten AO-MCP-Server:

- **Übersicht** — Was er bereitstellt
- **Sicherheit** — Schutzmechanismen und Zugriffskontrolle
- **Verfügbare Tools** — Vollständiger Tool-Katalog (nach Lesen/Schreiben klassifiziert)
- **Lokalen CLI-Agenten verbinden** — Snippet zum Registrieren als Remote-MCP in opencode

## Verfügbare MCP-Server

### 1. Eigene MCP-Server

Füge jeden MCP-kompatiblen Server hinzu (Dateisystem, Datenbank, API usw.):

```json
{
  "name": "My Database",
  "url": "http://db-mcp:3000",
  "headers": { "Authorization": "Bearer <token>" }
}
```

### 2. AO-MCP-Server (eingebaut)

Stellt die REST-API von Agent Orchestrator als MCP-Tools für Agenten und CLI bereit.

**Bereitgestellte Tools:**
| Tool | Typ | Beschreibung |
|------|------|-------------|
| `ao_list_agents` | lesen | Agenten im Workspace auflisten |
| `ao_get_agent` | lesen | Agent-Details abrufen |
| `ao_create_agent` | schreiben | Agent erstellen (nur Daemon, Admin-Berechtigung) |
| `ao_update_agent` | schreiben | Agent aktualisieren (nur Daemon, Admin-Berechtigung) |
| `ao_list_skills` | lesen | Skills auflisten |
| `ao_get_skill` | lesen | Skill-Details abrufen |
| `ao_create_skill` | schreiben | Skill-Entwurf erstellen |
| `ao_update_skill` | schreiben | Skill-Entwurf aktualisieren |
| `ao_assign_skill` | schreiben | Skill dem Agenten der Ausführung zuweisen |
| `ao_list_runs` | lesen | Ausführungen auflisten |
| `ao_get_run` | lesen | Details einer Ausführung abrufen |
| `ao_list_tasks` | lesen | Aufgaben auflisten |
| `ao_create_task` | schreiben | Aufgabe erstellen |
| `ao_list_runtimes` | lesen | Runtimes auflisten |
| `ao_search_knowledge` | lesen | Wissensbasis durchsuchen |

**Zugriffskontrolle:**
- Berechtigung **AO-Tools** pro Agent (Tab **Kontext**)
- Nur im Daemon-Modus (nicht in der Standalone-CLI)
- Der System-Administrator sieht den vollständigen Katalog unter Globale Einstellungen

### 3. Agent-Memory-MCP (eingebaut)

Gibt Agenten während Ausführungen RAG-Zugriff auf Wissensordner.

**Tools:**
| Tool | Beschreibung |
|------|-------------|
| `memory_search` | Semantische Suche über lesbare Ordner |
| `memory_remember` | Inhalte im persönlichen Ordner speichern |
| `memory_list_folders` | Zugängliche Ordner auflisten |
| `memory_create_folder` | Neuen persönlichen Ordner anlegen |

**Zugriff:**
- Pro Agent aktiviert über **Wissen einbeziehen** (Tab **Kontext**)
- Lesen = persönliche + Workspace-weite + Projektordner
- Schreiben = nur persönliche Ordner
- Wird pro Ausführung gestartet und beendet, wenn die Ausführung endet

## MCP-Server Agenten zuweisen

1. **Agent-Details** → Tab **MCP-Server**
2. Klicke auf **MCP-Server hinzufügen** → Konfiguration eingeben
3. Schalte **Aktiviert** ein, um den Server für diesen Agenten zu aktivieren
4. Zur Laufzeit werden aktivierte Server in den Kontext des Agenten eingespeist

## Sicherheit

Alle MCP-Verbindungen laufen über Schutzmechanismen:

| Schutzmechanismus | Zweck |
|-------|---------|
| **Nicht-Loopback-Host** | Blockiert externe Hosts im Daemon-Modus |
| **Nur JSON** | Weist POST-Anfragen ohne application/json ab |
| **Bearer-Auth** | Zufälliges Secret pro Ausführung (Daemon) oder `AO_MCP_LOCAL_SECRET` (Standalone) |
| **Berechtigungen pro Agent** | `include_ao_tools`, `include_knowledge`, `include_agent_admin` |

## In der Standalone-CLI verwenden

Registriere AO als Remote-MCP-Server in opencode:

```bash
# Snippet holen unter Globale Einstellungen → AO MCP → Lokalen CLI-Agenten verbinden
# Fügt der opencode-Konfiguration Folgendes hinzu:
{
  "mcpServers": {
    "agent-orchestrator": {
      "url": "https://your-ao.com/api/daemon/runs/<runId>/mcp",
      "headers": { "Authorization": "Bearer <per-run-secret>" }
    }
  }
}
```

## Letzte Neuerungen

- **AO-MCP-Server** — AO-REST-API als opencode-Tools für Agenten und CLI bereitstellen
- **Agent-Memory-MCP** — RAG-Suche, Speichern in persönlichen Ordnern während Ausführungen
- **Berechtigungen pro Agent** — Feingranulare Steuerung: AO-Tools, Wissen, Agent-Admin
- **Tool-Katalog** — Klassifizierung nach Lesen/Schreiben in den Globalen Einstellungen