Eigene MCP-Tools entwickeln

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über eigene MCP-Tools behandelt

• Wie Du eigene MCP-Tools für KI-Agenten entwickelst.
• Wie Du einen MCP-Server aufsetzt und Tools registrierst.
• Wie Du Custom Tools für spezifische Aufgaben baust.
• Praxisbeispiele für verschiedene Tool-Typen.
• Best Practices für Design, Sicherheit und Dokumentation.

Einleitung: Eigene MCP-Tools verständlich erklärt

Eigene MCP-Tools sind Custom-Integrations für Deine Agenten: Sie verbinden den Agent mit Deinen Systemen, APIs und Datenquellen. Nicht nur Standard-Tools, sondern spezialisierte Werkzeuge für Deine spezifischen Aufgaben.

Dieser Artikel richtet sich an Entwickler, die eigene MCP-Tools bauen wollen. Grundlagen findest Du in MCP und MCP-Berechtigungen.

Warum brauche ich eigene MCP-Tools?

Stell Dir vor, Dein Agent soll Dein internes CRM abfragen. Es gibt kein Standard-Tool dafür. Du baust ein eigenes MCP-Tool: „query_crm(customer_id) → Kundendaten”. Der Agent kann jetzt Dein CRM nutzen, spezialisiert für Deine Infrastruktur.

Eigene MCP-Tools kurz erklärt

MCP-Tool = Interface zwischen Agent und System. Du definierst: Tool-Name, Beschreibung, Parameter, Berechtigungen, Funktion. Der Agent nutzt das Tool über Tool-Calling.

Der Kerngedanke lautet: Custom-Integration für spezifische Aufgaben.

Für wen ist dieser Artikel gedacht?

• Entwickler, die Custom-Tools für Agenten bauen.
• Integration-Spezialisten, die Systeme verbinden.
• Agenten-Bauer, die spezialisierte Werkzeuge brauchen.
• DevOps, die eigene Tools deployen.

Wichtige Begriffe

• MCP - Model Context Protocol. Wann nützlich: für Tool-Integration.
• MCP-Berechtigungen - Zugriffskontrolle. Wann nützlich: für Sicherheit.
• Tool-Calling - Werkzeuge aufrufen. Wann nützlich: für Agenten.
• Ollama - Lokaler Modellserver. Wann nützlich: für Agenten.

MCP-Tool-Struktur

class CustomMCPTool:
    """Eigene MCP-Tool-Klasse"""

    def __init__(self):
        self.name = "custom_tool"
        self.description = "Was das Tool tut"
        self.permissions = {
            "allowed_actions": ["read", "write"],
            "rate_limit": 100
        }

    def get_tool_definition(self):
        """Tool-Definition für MCP"""
        return {
            "name": self.name,
            "description": self.description,
            "parameters": {
                "type": "object",
                "properties": {
                    "param1": {
                        "type": "string",
                        "description": "Parameter 1"
                    },
                    "param2": {
                        "type": "integer",
                        "description": "Parameter 2"
                    }
                },
                "required": ["param1"]
            }
        }

    def execute(self, param1, param2=None):
        """Tool ausführen"""
        # Berechtigungen prüfen
        self.check_permission("execute")

        # Tool-Logik
        result = self.do_something(param1, param2)

        return result

Praxisbeispiel 1: CRM-Tool

class CRMTool:
    """MCP-Tool für CRM-Integration"""

    def __init__(self, crm_api_url, api_key):
        self.api_url = crm_api_url
        self.api_key = api_key
        self.name = "query_crm"
        self.description = "CRM abfragen"

    def get_tool_definition(self):
        return {
            "name": self.name,
            "description": "Kundendaten aus CRM abfragen",
            "parameters": {
                "type": "object",
                "properties": {
                    "customer_id": {
                        "type": "string",
                        "description": "Kunden-ID"
                    },
                    "fields": {
                        "type": "array",
                        "items": {"type": "string"},
                        "description": "Felder die zurückgegeben werden sollen"
                    }
                },
                "required": ["customer_id"]
            }
        }

    def query_crm(self, customer_id, fields=None):
        """CRM abfragen"""
        # Berechtigungen prüfen
        self.check_permission("read")

        # API-Aufruf
        response = requests.get(
            f"{self.api_url}/customers/{customer_id}",
            headers={"Authorization": f"Bearer {self.api_key}"},
            params={"fields": fields}
        )

        return response.json()

Praxisbeispiel 2: E-Mail-Tool

class EmailTool:
    """MCP-Tool für E-Mail-Versand"""

    def __init__(self, smtp_config):
        self.smtp = smtp_config
        self.name = "send_email"
        self.description = "E-Mail senden"

    def get_tool_definition(self):
        return {
            "name": self.name,
            "description": "E-Mail senden",
            "parameters": {
                "type": "object",
                "properties": {
                    "to": {"type": "string", "description": "Empfänger"},
                    "subject": {"type": "string", "description": "Betreff"},
                    "body": {"type": "string", "description": "Text"}
                },
                "required": ["to", "subject", "body"]
            }
        }

    def send_email(self, to, subject, body):
        """E-Mail senden"""
        # Berechtigungen prüfen
        self.check_permission("send")

        # Rate-Limit prüfen
        self.check_rate_limit()

        # E-Mail senden
        msg = MIMEText(body)
        msg["Subject"] = subject
        msg["To"] = to

        with smtplib.SMTP(self.smtp["host"], self.smtp["port"]) as server:
            server.send_message(msg)

        return {"status": "sent", "to": to}

Praxisbeispiel 3: Web-Scraping-Tool

class WebScrapingTool:
    """MCP-Tool für Web-Scraping"""

    def __init__(self):
        self.name = "scrape_web"
        self.description = "Webseite scrapen"
        self.allowed_domains = ["example.com", "docs.example.com"]

    def get_tool_definition(self):
        return {
            "name": self.name,
            "description": "Webseite scrapen und Text extrahieren",
            "parameters": {
                "type": "object",
                "properties": {
                    "url": {"type": "string", "description": "URL"},
                    "selector": {"type": "string", "description": "CSS-Selector (optional)"}
                },
                "required": ["url"]
            }
        }

    def scrape_web(self, url, selector=None):
        """Webseite scrapen"""
        # Domain-Check
        domain = urlparse(url).netloc
        if domain not in self.allowed_domains:
            raise PermissionError(f"Domain '{domain}' not allowed")

        # Scraping
        response = requests.get(url)
        soup = BeautifulSoup(response.text, "html.parser")

        if selector:
            elements = soup.select(selector)
            return [e.get_text() for e in elements]
        else:
            return soup.get_text()

MCP-Server für eigene Tools

from mcp import Server, Tool

# MCP-Server erstellen
server = Server("custom-tools")

# Tools registrieren
server.add_tool(Tool(
    name="query_crm",
    description="CRM abfragen",
    parameters=crm_tool.get_tool_definition()["parameters"],
    function=crm_tool.query_crm
))

server.add_tool(Tool(
    name="send_email",
    description="E-Mail senden",
    parameters=email_tool.get_tool_definition()["parameters"],
    function=email_tool.send_email
))

# Server starten
server.run(port=8000)

Sicherheitshinweise

• Berechtigungen: Jedes Tool sollte Berechtigungen prüfen. Siehe MCP-Berechtigungen.
• Input-Validierung: Alle Parameter validieren (Type, Format, Range).
• Rate-Limiting: Für APIs und externe Calls Rate-Limits setzen.
• Secrets: API-Keys nicht im Code, sondern als Environment-Variablen.
• Audit: Alle Tool-Aufrufe loggen. Siehe Audit Logging.

Typische Stolpersteine

• Zu komplexe Tools: Ein Tool sollte eine klare Aufgabe haben. Nicht „Alles-Tool”.
• Schlechte Beschreibungen: Das Modell entscheidet anhand der Beschreibung. Präzise formulieren.
• Keine Fehlerbehandlung: Tool sollte Fehler gracefully handhaben und informative Fehler zurückgeben.
• Keine Dokumentation: Tool sollte gut dokumentiert sein (Parameter, Rückgabewerte, Fehler).
• Zu viele Parameter: Mehr als 3-4 Parameter überfordern das Modell. Komplexe Parameter als Objekt.

Weiterführende Links

• MCP - Model Context Protocol.
• MCP-Berechtigungen - Zugriffskontrolle.
• MCP-Dateisystem - Dateisystem-MCP.
• MCP-Sicherheit - Sicherheit.
• Tool-Berechtigungen - Berechtigungen.

Key Takeaways:

• Eigene MCP-Tools: Custom-Integration für spezifische Aufgaben.
• Tool-Struktur: Name, Beschreibung, Parameter, Berechtigungen, Funktion.
• MCP-Server: Tools registrieren, Agenten verbinden.
• Für CRM, E-Mail, Web-Scraping, interne APIs.
• Berechtigungen, Input-Validierung und Audit sind kritisch.

FAQ

Quellen und weiterführende Literatur

• MCP - Model Context Protocol.
• MCP Specification - Spezifikation.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert