# Erste Schritte: ToolMesh per Docker Compose starten

> ToolMesh in Minuten aufsetzen: git clone, .env (TOOLMESH_AUTH_PASSWORD oder TOOLMESH_API_KEY), docker compose up, claude mcp add. Production: OPENFGA_MODE=restrict.

Canonical: https://www.toolmesh.io/de/getting-started/

ToolMesh läuft als einzelne Go-Binary oder Docker-Container. Es stellt einen MCP-Server bereit, mit dem sich KI-Agenten verbinden.

## Voraussetzungen

- Docker und Docker Compose
- Ein KI-Agent, der MCP spricht (Claude Desktop, Claude Code, Claude.ai oder ein beliebiger MCP-Client)
- Optional: ein Reverse-Proxy für TLS (Caddy, Cloudflare Tunnel, nginx)

## Schnellstart

```bash
# Repository klonen
git clone https://github.com/DunkelCloud/ToolMesh.git
cd ToolMesh

# Konfiguration erstellen
cp .env.example .env
```

Öffne `.env` und setze mindestens eine Authentifizierungsmethode:

```bash
# Für interaktiven Login (Claude Desktop, Claude.ai):
TOOLMESH_AUTH_PASSWORD=my-secure-password

# Für programmatischen Zugriff (Claude Code, Skripte):
TOOLMESH_API_KEY=my-api-key
```

**Ohne Passwort oder API-Key werden alle Anfragen abgelehnt.**

> **Produktionshinweis:** Standardmäßig startet ToolMesh mit `OPENFGA_MODE=bypass` (keine Autorisierungsprüfungen). Das ist für lokale Entwicklung in Ordnung, aber für den Produktivbetrieb sollte `OPENFGA_MODE=restrict` gesetzt und OpenFGA konfiguriert werden. Siehe [Autorisierung](/de/authorization/) für Details.

```bash
# ToolMesh starten
docker compose up -d

# Prüfen, ob es läuft (Standard-Port: 8123)
curl http://localhost:8123/health
```

Der MCP-Endpunkt ist unter `http://localhost:8123/mcp` erreichbar.

:::tip[Konfigurationsänderungen anwenden]
Nach dem Bearbeiten von `.env` lädt ein einfaches `docker compose restart` die Umgebungsvariablen **nicht** neu. Verwende stattdessen:
```bash
docker compose down && docker compose up -d
```
:::

## TLS (Wichtig)

ToolMesh liefert reines HTTP aus. **Die meisten MCP-Clients — einschließlich Claude Desktop — erfordern HTTPS** und lehnen `http://`-URLs ab. Ein TLS-terminierender Reverse-Proxy vor ToolMesh ist nötig:

| Option | Einsatzzweck |
|--------|-------------|
| **Caddy** | Selbstgehostet mit öffentlicher Domain — automatische Let's-Encrypt-Zertifikate |
| **Cloudflare Tunnel** | Keine offenen Ports nötig, TLS ohne Konfiguration |
| **nginx / Traefik** | Bereits im Stack vorhanden |

Für die **lokale Entwicklung** kann TLS umgangen werden, indem `claude_desktop_config.json` manuell bearbeitet wird (die GUI erzwingt `https://`).

## KI-Agent verbinden

### Claude Desktop

Zur Claude Desktop MCP-Konfiguration (`claude_desktop_config.json`) hinzufügen:

```json
{
  "mcpServers": {
    "toolmesh": {
      "url": "https://toolmesh.example.com/mcp"
    }
  }
}
```

Für lokale Entwicklung ohne TLS-Proxy:

```json
{
  "mcpServers": {
    "toolmesh": {
      "url": "http://localhost:8123/mcp"
    }
  }
}
```

### Claude.ai (Custom Connector)

ToolMesh unterstützt OAuth 2.1 mit PKCE S256 für Remote-Zugriff. Benutzer werden in `config/users.yaml` konfiguriert, die öffentliche HTTPS-URL dient als MCP-Endpunkt.

### Claude Code

Claude Code verbindet sich per API-Key. Setze `TOOLMESH_API_KEY` in der `.env` und füge den MCP-Endpunkt hinzu:

```bash
claude mcp add -t http -H "Authorization: Bearer MY_API_KEY" -s user toolmesh http://localhost:8123/mcp
```

## Backend hinzufügen

Backends werden in `config/backends.yaml` konfiguriert.

### MCP-Backend (einen bestehenden MCP-Server proxyen)

```yaml
backends:
  - name: memorizer
    transport: http
    url: "https://memorizer.example.com/mcp"
    api_key_env: "MEMORIZER_API_KEY"
```

Die Zugangsdaten als Umgebungsvariable in `.env` setzen:

```bash
CREDENTIAL_MEMORIZER_API_KEY=sk-mem-xxxxx
```

Zugangsdaten werden zur Laufzeit injiziert — das LLM sieht nie API-Keys.

### REST-Backend (via DADL)

Statt einen MCP-Wrapper-Server zu bauen, kann die REST-API deklarativ in einer `.dadl`-Datei beschrieben werden:

```yaml
backends:
  - name: github
    transport: rest
    dadl: /app/dadl/github.dadl
    url: "https://api.github.com"
```

DADL-Dateien gibt es in der [DADL Registry](https://dadl.ai/browse) oder können mit dem LLM generiert werden:

> „Erstelle eine DADL für die GitHub-API — Repos auflisten, Issues öffnen und Pull Requests erstellen."

## Nächste Schritte

- [Architektur](/de/architecture/) — die Ausführungs-Pipeline verstehen
- [DADL](/de/dadl/) — REST-APIs ohne Code beschreiben
- [Konfiguration](/de/configuration/) — alle Umgebungsvariablen
- [Authentifizierung](/de/authentication/) — OAuth 2.1, API-Keys, Multi-User