Blog
Standpunkt

Was sind MCP-Server? Verständlich erklärt

Was ist MCP Server & warum reden alle darüber? Finde es in diesem Artikel heraus!

Leo Schulz

Leo Schulz

5 June 2025

Was sind MCP-Server? Verständlich erklärt

Das Model Context Protocol (MCP), eingeführt von Anthropic am 26. November 2024, ist ein offener Standard, der darauf abzielt, die Lücke zwischen KI-Modellen und externen Datenquellen zu schließen. Dieses Protokoll adressiert eine kritische Herausforderung: Selbst fortschrittliche Large Language Models (LLMs) sind, obwohl sie leistungsstark in der Texterzeugung sind, oft von Echtzeitdaten und -tools isoliert, was ihre praktische Nützlichkeit einschränkt. MCP-Server, als integrale Komponenten, ermöglichen KI-Assistenten wie Claude den Zugriff auf Dateien, Datenbanken, APIs und mehr, wodurch ihre Fähigkeit verbessert wird, relevante, umsetzbare Antworten zu liefern.

Die Bedeutung von MCP liegt in seinem Potenzial, Integrationen zu standardisieren und die Fragmentierung zu reduzieren, die die KI-Entwicklung geplagt hat. Durch die Bereitstellung eines universellen Protokolls zielt es darauf ab, Grenzmodellen zu helfen, bessere, relevantere Antworten zu erzeugen, indem Informationssilos und Barrieren in Altsystemen abgebaut werden.

Ab dem 25. März 2025 wächst das Ökosystem rasant, mit Beiträgen aus der Community und Unternehmensübernahmen, wie z. B. frühen Anwendern wie Block und Apollo, die MCP in ihre Systeme integrieren.

💡
Müssen Sie das beste Postman-Alternative-Tool finden, das Ihren gesamten API-Test-Workflow an einem Ort integriert?
Laden Sie Apidog noch heute kostenlos herunter und entdecken Sie, wie es Ihren Workflow verändern kann!
button

Was sind MCP-Server?

MCP-Server, Teil des Model Context Protocol (MCP), sind spezielle Programme, die KI-Modellen, wie denen von Anthropic, helfen, sich mit externen Daten und Tools zu verbinden und diese zu nutzen. Sie wurden im November 2024 eingeführt und ermöglichen es der KI, mehr als nur Text zu generieren, indem sie auf Dinge wie Dateien auf Ihrem Computer, Datenbanken oder sogar Dienste wie GitHub zugreift, und das alles auf sichere und standardisierte Weise.

Stellen Sie sich MCP-Server als Brücken vor, die es der KI ermöglichen, mit der Außenwelt zu interagieren, ähnlich wie USB-Anschlüsse es Ihnen ermöglichen, verschiedene Geräte an Ihren Computer anzuschließen. Wenn Sie beispielsweise eine KI bitten, ein Dokument zusammenzufassen, kann sie die Datei direkt von Ihrem System abrufen. Oder, wenn Sie ein GitHub-Problem erstellen müssen, kann die KI dies auch tun, dank eines MCP-Servers. Sie können Daten (wie Dateien), Tools (wie API-Aufrufe) oder Prompts (Anleitungen für die Interaktion) bereitstellen und so die KI nützlicher für Aufgaben wie Codierung, Forschung oder Projektmanagement machen.

Quelle: Norah Sakal's Blog

Ein unerwartetes Detail ist, wie schnell die Community gewachsen ist, mit über 250 bereits verfügbaren Servern, einschließlich offizieller Integrationen und Community-Beiträgen, was ein lebendiges Ökosystem zeigt, das schnell expandiert.

Wie MCP-Server funktionieren (und wie sie sich von APIs unterscheiden)

MCP arbeitet nach einem Client-Server-Modell, wie in der Dokumentation beschrieben. Die Architektur umfasst:

Quelle: Tahir

Das Protokoll basiert auf JSON-RPC 2.0 und gewährleistet zustandsbehaftete Verbindungen und Fähigkeitsverhandlungen zwischen Clients und Servern. Diese technische Grundlage ermöglicht eine robuste, sichere Kommunikation mit Funktionen wie Fortschrittsverfolgung, Abbruch und Fehlerberichterstattung, die die Zuverlässigkeit erhöhen.

Also, was können MCPs tatsächlich tun?

MCP-Server sind so konzipiert, dass sie vielseitig einsetzbar sind und eine Vielzahl von Anforderungen erfüllen. Sie können lokal oder remote ausgeführt werden, abhängig von der Implementierung, und basieren auf Sicherheitsprinzipien. Jeder Server kontrolliert seine eigenen Ressourcen und wahrt klare Systemgrenzen, um unbefugten Zugriff zu verhindern.

Diese Sicherheit ist entscheidend, insbesondere im Umgang mit sensiblen Daten, um sicherzustellen, dass Verbindungen sicher sind und Berechtigungen streng verwaltet werden.

Technisch gesehen machen Server ihre Fähigkeiten über JSON-RPC-Endpunkte verfügbar, sodass Clients verfügbare Ressourcen, Tools und Prompts abfragen können.

Beispielsweise könnte ein Server eine "readFile"-Ressource verfügbar machen, die den Inhalt einer angegebenen Datei zurückgibt, oder ein "createIssue"-Tool, das mit der API von GitHub interagiert. Das Protokoll unterstützt auch serverinitiierte Verhaltensweisen wie Sampling, wodurch agentische KI-Interaktionen ermöglicht werden, die rekursiv und dynamisch sein können, wie in der Spezifikation beschrieben.

Interessiert an MCP-Servern? Sie können diese jetzt ausprobieren

Das Ökosystem der MCP-Server ist reichhaltig und wächst, mit zahlreichen Beispielen, die ihren Nutzen veranschaulichen, wie im Repository unter GitHub - awesome-mcp-servers aufgeführt:

💡
Möchten Sie 1000+ weitere MCP-Server erkunden?

Erfahren Sie mehr unter Himcp.ai!
button

Was ist der Unterschied zwischen MCP-Servern und APIs?

Quelle: Norah Sakal's Blog

Während sowohl MCP-Server als auch herkömmliche APIs es Software ermöglichen, mit externen Diensten zu interagieren, unterscheiden sich ihre Zwecke im KI-Kontext:

In einem herkömmlichen Setup müsste die KI beispielsweise möglicherweise eine REST-API aufrufen, um Wetterdaten abzurufen, JSON-Antworten zu analysieren und sie in ihren Kontext zu integrieren. Mit einem MCP-Server könnte der Server ein "get_weather"-Tool verfügbar machen, und die KI ruft es einfach mit Parametern auf und empfängt formatierte Daten, die sofort verwendet werden können.

So richten Sie MCP-Server ein (mit Claude als Beispiel)

Model Context Protocol (MCP) ist ein leistungsstarkes Framework, das Folgendes ermöglicht:

MCP-Server können drei Haupttypen von Funktionen bereitstellen:

Einrichten Ihrer Umgebung

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

Installieren des UV-Paketmanagers

UV ist der empfohlene Paketmanager für Python-MCP-Projekte:

# MacOS/Linux
curl -LsSf <https://astral.sh/uv/install.sh> | sh

# Achten Sie darauf, Ihr Terminal danach neu zu starten

Erstellen eines MCP-Servers

Lassen Sie uns als Beispiel einen einfachen Wetterservice erstellen.

Dieser Server stellt zwei Tools bereit: get-alerts und get-forecast.

Schritt 1: Projektstruktur einrichten

# Erstellen Sie ein neues Verzeichnis für unser Projekt
uv init weather
cd weather

# Erstellen Sie eine virtuelle Umgebung und aktivieren Sie sie
uv venv
source .venv/bin/activate  # On Windows: .venv\\\\Scripts\\\\activate

# Installieren Sie Abhängigkeiten
uv add "mcp[cli]" httpx

# Erstellen Sie unsere Serverdatei
touch weather.py

Schritt 2: Implementieren Sie den Server

Hier ist eine vollständige Implementierung unseres Wetterservice (in weather.py):

from typing import Any
import httpx
from mcpserver.fastmcp import FastMCP

# Initialisieren Sie den FastMCP-Server
mcp = FastMCP("weather")

# Konstanten
NWS_API_BASE = "<https://api.weather.gov>"
USER_AGENT = "weather-app/1.0"

async def make_nws_request(url: str) -> dict[str, Any] | None:
    """Stellen Sie eine Anfrage an die NWS-API mit ordnungsgemäßer Fehlerbehandlung."""
    headers = {
        "User-Agent": USER_AGENT,
        "Accept": "application/geo+json"
    }
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url, headers=headers, timeout=30.0)
            response.raise_for_status()
            return response.json()
        except Exception:
            return None

def format_alert(feature: dict) -> str:
    """Formatieren Sie ein Warnungsmerkmal in eine lesbare Zeichenfolge."""
    props = feature["properties"]
    return f"""
Event: {props.get('event', 'Unknown')}
Area: {props.get('areaDesc', 'Unknown')}
Severity: {props.get('severity', 'Unknown')}
Description: {props.get('description', 'No description available')}
Instructions: {props.get('instruction', 'No specific instructions provided')}
"""

@mcp.tool()
async def get_alerts(state: str) -> str:
    """Holen Sie sich Wetterwarnungen für einen US-Bundesstaat.

    Args:
        state: Zweibuchstabiger US-Bundesstaatscode (z. B. CA, NY)
    """
    url = f"{NWS_API_BASE}/alerts/active/area/{state}"
    data = await make_nws_request(url)

    if not data or "features" not in data:
        return "Warnungen konnten nicht abgerufen werden oder es wurden keine Warnungen gefunden."

    if not data["features"]:
        return "Keine aktiven Warnungen für diesen Staat."

    alerts = [format_alert(feature) for feature in data["features"]]
    return "\\\\n---\\\\n".join(alerts)

@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:
    """Holen Sie sich die Wettervorhersage für einen Ort.

    Args:
        latitude: Breitengrad des Ortes
        longitude: Längengrad des Ortes
    """
    # Holen Sie sich zuerst den Endpunkt des Vorhersagegitters
    points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
    points_data = await make_nws_request(points_url)

    if not points_data:
        return "Vorhersagedaten für diesen Ort konnten nicht abgerufen werden."

    # Holen Sie sich die Vorhersage-URL aus der Antwort der Punkte
    forecast_url = points_data["properties"]["forecast"]
    forecast_data = await make_nws_request(forecast_url)

    if not forecast_data:
        return "Detaillierte Vorhersage konnte nicht abgerufen werden."

    # Formatieren Sie die Perioden in eine lesbare Vorhersage
    periods = forecast_data["properties"]["periods"]
    forecasts = []
    for period in periods[:5]:  # Zeigen Sie nur die nächsten 5 Perioden an
        forecast = f"""
{period['name']}: Temperatur: {period['temperature']}°{period['temperatureUnit']}
Wind: {period['windSpeed']} {period['windDirection']}
Forecast: {period['detailedForecast']}
"""
        forecasts.append(forecast)

    return "\\\\n---\\\\n".join(forecasts)

if __name__ == "__main__":
    # Initialisieren und führen Sie den Server aus
    mcp.run(transport='stdio')

Schritt 3: Führen Sie Ihren Server aus

Um Ihren Server direkt zu testen, führen Sie Folgendes aus:

uv run weather.py

Verbinden mit Claude for Desktop

Claude for Desktop ist eine einfache Möglichkeit, mit Ihren MCP-Servern zu interagieren.

Schritt 1: Installieren Sie Claude for Desktop

Stellen Sie sicher, dass Sie Claude for Desktop installiert und auf die neueste Version aktualisiert haben.

Schritt 2: Konfigurieren Sie Claude for Desktop

  1. Öffnen Sie Ihre Claude for Desktop App-Konfiguration in einem Texteditor:
# macOS
code ~/Library/Application\\\\ Support/Claude/claude_desktop_config.json

2. Fügen Sie Ihre Serverkonfiguration hinzu:

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": [
        "--directory",
        "/ABSOLUTE/PATH/TO/PARENT/FOLDER/weather",
        "run",
        "weather.py"
      ]
    }
  }
}

Achten Sie darauf:

Schritt 3: Starten Sie Claude for Desktop neu

Starten Sie Claude for Desktop nach dem Speichern der Konfiguration vollständig neu.

Schritt 4: Testen Sie Ihren Server

Suchen Sie nach dem Hammersymbol in der unteren rechten Ecke des Eingabefelds von Claude for Desktop. Wenn Sie darauf klicken, sollten die Tools Ihres Servers angezeigt werden.

Sie können Claude jetzt Fragen stellen wie:

Erstellen eines benutzerdefinierten MCP-Clients für Claude MCP-Server

Anstatt Claude for Desktop zu verwenden, können Sie Ihren eigenen benutzerdefinierten Client erstellen.

Schritt 1: Richten Sie das Client-Projekt ein

# Erstellen Sie das Projektverzeichnis
uv init mcp-client
cd mcp-client

# Erstellen Sie eine virtuelle Umgebung
uv venv
source .venv/bin/activate  # On Windows: .venv\\\\Scripts\\\\activate

# Installieren Sie die erforderlichen Pakete
uv add mcp anthropic python-dotenv

# Erstellen Sie unsere Hauptdatei
touch client.py

Schritt 2: Richten Sie Ihren API-Schlüssel ein

Erstellen Sie eine .env-Datei mit Ihrem Anthropic-API-Schlüssel:

ANTHROPIC_API_KEY=<your key here>

Schritt 3: Implementieren Sie den Client

Hier ist eine grundlegende Client-Implementierung (in client.py):

import asyncio
import sys
from typing import Optional
from contextlib import AsyncExitStack

from mcp.client.stdio import ClientSession, StdioServerParameters, stdio_client
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()  # Laden Sie Umgebungsvariablen aus .env

class MCPClient:
    def __init__(self):
        # Initialisieren Sie Sitzungs- und Client-Objekte
        self.session: Optional[ClientSession] = None
        self.exit_stack = AsyncExitStack()
        self.anthropic = Anthropic()

    async def connect_to_server(self, server_script_path: str):
        """Verbinden Sie sich mit einem MCP-Server

        Args:
            server_script_path: Pfad zum Serverskript (py oder js)
        """
        is_python = server_script_path.endswith('.py')
        is_js = server_script_path.endswith('.js')

        if not (is_python or is_js):
            raise ValueError("Das Serverskript muss eine .py- oder .js-Datei sein")

        command = "python" if is_python else "node"
        server_params = StdioServerParameters(command=command, args=[server_script_path], env=None)

        stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
        self.stdio, self.write = stdio_transport
        self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
        await self.session.initialize()

        # Listen Sie die verfügbaren Tools auf
        response = await self.session.list_tools()
        tools = response.tools
        print("\\\\nVerbunden mit Server mit Tools:", [tool.name for tool in tools])

    async def process_query(self, query: str) -> str:
        """Verarbeiten Sie eine Abfrage mit Claude und verfügbaren Tools"""
        messages = [
            {
                "role": "user",
                "content": query
            }
        ]

        response = await self.session.list_tools()
        available_tools = [{
            "name": tool.name,
            "description": tool.description,
            "input_schema": tool.input_schema
        } for tool in response.tools]

        # Erster Claude-API-Aufruf
        response = self.anthropic.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1000,
            messages=messages,
            tools=available_tools
        )

        # Verarbeiten Sie die Antwort und verarbeiten Sie Toolaufrufe
        final_text = []
        assistant_message_content = []

        for content in response.content:
            if content.type == 'text':
                final_text.append(content.text)
                assistant_message_content.append(content)
            elif content.type == 'tool_use':
                tool_name = content.name
                tool_args = content.input

                # Führen Sie den Toolaufruf aus
                result = await self.session.call_tool(tool_name, tool_args)
                final_text.append(f"[Aufrufen des Tools {tool_name} mit Argumenten {tool_args}]")
                assistant_message_content.append(content)

                messages.append({
                    "role": "assistant",
                    "content": assistant_message_content
                })

                messages.append({
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": content.id,
                            "content": result
                        }
                    ]
                })

                # Holen Sie sich die nächste Antwort von Claude
                response = self.anthropic.messages.create(
                    model="claude-3-5-sonnet-20241022",
                    max_tokens=1000,
                    messages=messages,
                    tools=available_tools
                )

                final_text.append(response.content[0].text)

        return "\\\\n".join(final_text)

    async def chat_loop(self):
        """Führen Sie eine interaktive Chat-Schleife aus"""
        print("\\\\nMCP-Client gestartet!")
        print("Geben Sie Ihre Abfragen ein oder 'quit', um zu beenden.")

        while True:
            try:
                query = input("\\\\nQuery: ").strip()
                if query.lower() == 'quit':
                    break

                response = await self.process_query(query)
                print("\\\\n" + response)
            except Exception as e:
                print(f"\\\\nError: {str(e)}")

    async def cleanup(self):
        """Bereinigen Sie Ressourcen"""
        await self.exit_stack.aclose()

async def main():
    if len(sys.argv) < 2:
        print("Verwendung: python client.py <path_to_server_script>")
        sys.exit(1)

    client = MCPClient()

    try:
        await client.connect_to_server(sys.argv[1])
        await client.chat_loop()
    finally:
        await client.cleanup()

if __name__ == "__main__":
    asyncio.run(main())

Schritt 4: Führen Sie den Client aus

So verwenden Sie Ihren Client mit Ihrem Wetterservice:

uv run client.py /path/to/weather.py

Verwenden von vorgefertigten MCP-Servern mit Claude for Desktop

Claude for Desktop unterstützt eine Vielzahl von vorgefertigten MCP-Servern. Sehen wir uns an, wie man einen Dateisystemserver als Beispiel verwendet.

Schritt 1: Konfigurieren Sie den Dateisystemserver

  1. Öffnen Sie die Claude for Desktop-Einstellungen und klicken Sie auf "Konfiguration bearbeiten"
  2. Aktualisieren Sie Ihre Konfigurationsdatei mit:
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Desktop",
        "/Users/username/Downloads"
      ]
    }
  }
}

Ersetzen Sie username durch Ihren tatsächlichen Benutzernamen und passen Sie die Pfade nach Bedarf an.

Schritt 2: Neustart und Test

Nach dem Neustart von Claude for Desktop können Sie die Dateisystem-Tools verwenden, um:

Beispielaufforderungen:

Fazit

MCP-Server stellen einen bedeutenden Fortschritt in der KI-Funktionalität dar und schließen die Lücke zwischen leistungsstarken Sprachmodellen und externen Tools. Indem Sie dieser Anleitung folgen, haben Sie gelernt, wie Sie MCP-Server erstellen, konfigurieren und verwenden, um die Fähigkeiten von Claude zu erweitern.

Der standardisierte Ansatz des Model Context Protocol stellt sicher, dass KI-Modelle in der Lage sind, in Echtzeit auf Daten zuzugreifen, Aktionen auszuführen und auf sichere, kontrollierte Weise mit Systemen zu interagieren. Dies macht KI-Assistenten praktischer für reale Anwendungen in den Bereichen Entwicklung, Datenanalyse, Inhaltserstellung und mehr.

Da das MCP-Ökosystem weiter wächst, erstellen Entwickler immer ausgefeiltere Server, die die Möglichkeiten der KI erweitern. Unabhängig davon, ob Sie vorgefertigte Server verwenden oder benutzerdefinierte Lösungen entwickeln, bietet MCP eine flexible Grundlage für den Aufbau leistungsfähigerer KI-Anwendungen.


Da Sie weiterhin mit MCP-Servern arbeiten, die häufig API-Integrationen beinhalten, möchten Sie möglicherweise Apidog erkunden, eine umfassende API-Entwicklungsplattform, die Ihren MCP-Implementierungs-Workflow ergänzen kann.

Apidog bietet eine All-in-One-Lösung für API-Design, -Dokumentation, -Debugging und automatisiertes Testen. Die intuitive Benutzeroberfläche macht es einfach, Folgendes zu tun:

Bei der Entwicklung von MCP-Servern, die mit externen APIs interagieren, kann Apidog Ihnen helfen, Endpunkte zu validieren, Antwortstrukturen zu verstehen und sicherzustellen, dass Ihre Integrationen korrekt funktionieren, bevor Sie sie in Ihrem Servercode implementieren.

Um mit Apidog neben Ihrer MCP-Entwicklung zu beginnen, besuchen Sie

Explore more

Fathom-R1-14B: Fortschrittliches KI-Argumentationsmodell aus Indien

Fathom-R1-14B: Fortschrittliches KI-Argumentationsmodell aus Indien

Künstliche Intelligenz wächst rasant. FractalAIResearch/Fathom-R1-14B (14,8 Mrd. Parameter) glänzt in Mathe & Logik.

5 June 2025

Cursor 1.0 mit BugBot: KI-gestütztes Automatisierungstest-Tool ist da:

Cursor 1.0 mit BugBot: KI-gestütztes Automatisierungstest-Tool ist da:

Die Softwareentwicklung erlebt Innovationen durch KI. Cursor, ein KI-Editor, erreicht mit Version 1.0 einen Meilenstein.

5 June 2025

30+ öffentliche Web 3.0 APIs, die Sie jetzt nutzen können

30+ öffentliche Web 3.0 APIs, die Sie jetzt nutzen können

Der Aufstieg von Web 3.0: Dezentral, nutzerorientiert, transparent. APIs ermöglichen innovative dApps und Blockchain-Integration.

4 June 2025

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen

Kostenlos registrierenDownload