Eigene Erweiterungen erstellen¶

Verbinde DeskAgent mit jedem Service durch deine eigene MCP-Integration

DeskAgent kann durch eigene MCP-Server (Model Context Protocol) erweitert werden. Damit kannst du jede API, jeden Service oder jedes System mit deinem KI-Assistenten verbinden.

Für Entwickler

Diese Anleitung richtet sich an Entwickler und technisch versierte Nutzer. Du brauchst grundlegende Python-Kenntnisse und Erfahrung mit APIs.

Gute Nachricht: Mit KI-Coding-Assistenten wie Claude ist das Erstellen von Erweiterungen viel einfacher als früher. Die KI schreibt den größten Teil des Codes für dich!

Was du brauchst¶

Empfohlenes Setup¶

Tool	Warum	Link
VS Code	Bester Editor für Python-Entwicklung	code.visualstudio.com
Claude Code CLI	KI-Assistent der Code für dich schreibt	claude.ai/code
Python 3.10+	Bereits bei DeskAgent dabei	-

KI-gestützte Entwicklung

Mit Claude Code CLI in VS Code beschreibst du einfach was du willst:

"Erstelle einen MCP-Server der sich mit der Trello-API verbindet und Tools bereitstellt um Boards aufzulisten, Karten zu erstellen und Karten zwischen Listen zu verschieben"

Claude generiert den kompletten Code, inklusive Fehlerbehandlung und Dokumentation.

Wie Erweiterungen funktionieren¶

graph LR
    A[Deine Erweiterung] --> B[DeskAgent]
    B --> C[KI-Agent]
    C --> D[Nutzt deine Tools]
    D --> E[Externer Service]

Jede Erweiterung ist eine Python-Datei die:

Tools definiert die die KI nutzen kann (suchen, erstellen, aktualisieren, etc.)
Sich mit APIs verbindet mit deinen Zugangsdaten
Ergebnisse zurückgibt die die KI verstehen und verwenden kann

Schnellstart: Deine erste Erweiterung¶

Schritt 1: Template kopieren¶

Erstelle eine neue Datei in deskagent/mcp/:

deskagent/mcp/meinservice_mcp.py

Schritt 2: Template verwenden¶

#!/usr/bin/env python3
"""
Mein Service MCP Server
Verbindet DeskAgent mit Mein Service.
"""

import sys
import json
from pathlib import Path
from mcp.server.fastmcp import FastMCP

# Setup
sys.path.insert(0, str(Path(__file__).parent.parent / "scripts"))
from paths import load_config

mcp = FastMCP("meinservice")

# Erforderlich: Icon und Farbe für die WebUI
TOOL_METADATA = {
    "icon": "extension",      # Material Icons Name
    "color": "#2196f3"        # Deine Markenfarbe
}

# API-Zugangsdaten aus config/apis.json laden
def get_config():
    config = load_config()
    return config.get("meinservice", {})

# Deine Tools definieren
@mcp.tool()
def suche_eintraege(suchbegriff: str, limit: int = 10) -> str:
    """
    Suche nach Einträgen in Mein Service.

    Args:
        suchbegriff: Suchbegriffe
        limit: Maximale Ergebnisse (Standard: 10)

    Returns:
        JSON mit passenden Einträgen
    """
    config = get_config()
    api_key = config.get("api_key")

    # Dein API-Aufruf hier
    ergebnisse = []

    return json.dumps(ergebnisse, indent=2)

# Einstiegspunkt
if __name__ == "__main__":
    mcp.run()

Schritt 3: Konfiguration hinzufügen¶

Füge deine Zugangsdaten zu config/apis.json hinzu:

{
  "meinservice": {
    "enabled": true,
    "api_key": "dein-api-key-hier",
    "base_url": "https://api.meinservice.de"
  }
}

Schritt 4: DeskAgent neu starten¶

Deine Erweiterung ist jetzt verfügbar! Die KI kann deine neuen Tools nutzen.

Icons finden¶

Durchsuche Material Icons auf fonts.google.com/icons

Beliebte Auswahl:

Icon Name	Vorschau	Gut für
`mail`		E-Mail-Dienste
`payments`		Abrechnung/Finanzen
`folder`		Dateiverwaltung
`cloud`		Cloud-Dienste
`support_agent`		Support/Helpdesk
`inventory_2`		Archive/Speicher

Best Practices¶

1. Klare Tool-Beschreibungen¶

Die KI liest deine Docstrings um zu verstehen was Tools tun:

@mcp.tool()
def erstelle_aufgabe(titel: str, faellig_am: str = None) -> str:
    """
    Erstelle eine neue Aufgabe im Projekt.

    Args:
        titel: Aufgabentitel (erforderlich)
        faellig_am: Optionales Fälligkeitsdatum (Format: YYYY-MM-DD)

    Returns:
        JSON mit den erstellten Aufgabendetails
    """

2. JSON zurückgeben¶

Gib immer strukturierte Daten zurück:

return json.dumps({
    "success": True,
    "id": neuer_eintrag.id,
    "message": "Eintrag erfolgreich erstellt"
}, indent=2)

3. Fehler elegant behandeln¶

try:
    ergebnis = api.erstellen(daten)
    return json.dumps({"success": True, "data": ergebnis})
except Exception as e:
    return json.dumps({"error": str(e)})

Beispiel: Trello-Integration¶

Hier ist ein vollständiges Beispiel für die Verbindung mit Trello:

#!/usr/bin/env python3
"""Trello MCP - Verwalte Trello-Boards mit DeskAgent."""

import sys
import json
import requests
from pathlib import Path
from mcp.server.fastmcp import FastMCP

sys.path.insert(0, str(Path(__file__).parent.parent / "scripts"))
from paths import load_config

mcp = FastMCP("trello")

TOOL_METADATA = {
    "icon": "dashboard",
    "color": "#0079bf"  # Trello-Blau
}

def get_config():
    config = load_config()
    return config.get("trello", {})

def api_request(endpoint, method="GET", data=None):
    config = get_config()
    url = f"https://api.trello.com/1{endpoint}"
    params = {
        "key": config["api_key"],
        "token": config["token"]
    }
    response = requests.request(method, url, params=params, json=data)
    return response.json()

@mcp.tool()
def liste_boards() -> str:
    """Liste alle deine Trello-Boards auf."""
    boards = api_request("/members/me/boards")
    return json.dumps([{"id": b["id"], "name": b["name"]} for b in boards], indent=2)

@mcp.tool()
def erstelle_karte(listen_id: str, name: str, beschreibung: str = "") -> str:
    """
    Erstelle eine neue Karte in einer Trello-Liste.

    Args:
        listen_id: Die ID der Liste
        name: Kartentitel
        beschreibung: Optionale Kartenbeschreibung
    """
    karte = api_request(f"/cards", "POST", {
        "idList": listen_id,
        "name": name,
        "desc": beschreibung
    })
    return json.dumps({"success": True, "card_id": karte["id"]})

if __name__ == "__main__":
    mcp.run()

Hilfe bekommen¶

Lass die KI deine Erweiterung schreiben¶

Öffne deinen DeskAgent-Ordner in VS Code
Installiere die Claude Code CLI Extension
Beschreibe was du verbinden willst
Claude generiert den Code
Testen und verfeinern

Bestehende Erweiterungen als Referenz¶

Schau dir vorhandene MCP-Server in deskagent/mcp/ als Beispiele an:

Erweiterung	API-Typ	Gutes Beispiel für
`billomat_mcp.py`	REST API	Rechnungsstellung/Business
`outlook_mcp.py`	COM/Lokal	Desktop-Integration
`paperless_mcp.py`	REST API	Dokumentenverwaltung
`userecho_mcp.py`	REST API	Support-Tickets

Nächste Schritte¶

API-Dokumentation

Prüfe die API-Docs deines Ziel-Services
Nutze Claude Code

Lass die KI dir bei der Integration helfen
Teste deine Erweiterung

Starte DeskAgent neu und probiere deine neuen Tools