Bild vom Autor

# Einführung

Das Mannequin Context Protocol (MCP) hat die Artwork und Weise verändert, wie große Sprachmodelle (LLMs) mit externen Instruments, Datenquellen und Diensten interagieren. Der Aufbau von MCP-Servern von Grund auf erforderte jedoch traditionell die Navigation in komplexem Standardcode und detaillierten Protokollspezifikationen. FastMCP beseitigt dieses Hindernis und stellt ein auf Dekoratoren basierendes Pythonic-Framework bereit, das es Entwicklern ermöglicht, mit minimalem Code produktionsbereite MCP-Server und -Purchasers zu erstellen.

In diesem Tutorial erfahren Sie, wie Sie MCP-Server und -Purchasers mit FastMCP erstellen, das umfassend und umfassend mit Fehlerbehandlung ausgestattet ist und sich daher sowohl für Anfänger als auch für fortgeschrittene Entwickler eignet.

// Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:

• Python 3.10 oder höher (3.11+ empfohlen für bessere asynchrone Leistung)
• pip oder uv (uv wird für die FastMCP-Bereitstellung empfohlen und ist für die CLI-Instruments erforderlich)
• Ein Code-Editor (ich verwende VS-Code, aber Sie können jeden beliebigen Editor Ihrer Wahl verwenden)
• Vertrautheit mit Terminal/Befehlszeile zum Ausführen von Python-Skripten

Es ist außerdem von Vorteil, über gute Python-Programmierkenntnisse (Funktionen, Dekoratoren, Typhinweise), ein gewisses Verständnis der Async/Await-Syntax (non-compulsory, aber hilfreich für fortgeschrittene Beispiele), Vertrautheit mit JSON- und REST-API-Konzepten sowie grundlegende Verwendung von Befehlszeilenterminals zu verfügen.

Vor FastMCP erforderte der Aufbau von MCP-Servern ein tiefes Verständnis der MCP-JSON-RPC-Spezifikation, umfangreiche Boilerplate-Codes für die Protokollverarbeitung, manuelle Verbindungs- und Transportverwaltung sowie komplexe Fehlerbehandlungs- und Validierungslogik.

FastMCP geht diese Probleme mit intuitiven Dekoratoren und einer einfachen Pythonic-API an, sodass Sie sich auf die Geschäftslogik statt auf die Protokollimplementierung konzentrieren können.

# Was ist das Mannequin Context Protocol?

Das Mannequin Context Protocol (MCP) ist ein offener Commonplace, der von Anthropic entwickelt wurde. Es bietet eine universelle Schnittstelle für KI-Anwendungen zur sicheren Verbindung mit externen Instruments, Datenquellen und Diensten. MCP standardisiert die Interaktion von LLMs mit externen Systemen, ähnlich wie Net-APIs die Kommunikation von Webdiensten standardisierten.

// Hauptmerkmale von MCP

• Standardisierte Kommunikation: Verwendet JSON-RPC 2.0 für zuverlässige, strukturierte Nachrichtenübermittlung
• Bidirektional: Unterstützt sowohl Anfragen von Purchasers an Server als auch Antworten zurück
• Sicherheit: Integrierte Unterstützung für Authentifizierungs- und Autorisierungsmuster
• Flexibler Transport: Funktioniert mit jedem Transportmechanismus (stdio, HTTP, WebSocket, SSE)

// MCP-Architektur: Server und Purchasers

MCP folgt einer klaren Consumer-Server-Architektur:

Bild vom Autor

• MCP-Server: Stellt Funktionen (Instruments, Ressourcen, Eingabeaufforderungen) bereit, die externe Anwendungen verwenden können. Betrachten Sie es als eine Backend-API, die speziell für die LLM-Integration entwickelt wurde.
• MCP-Consumer: Eingebettet in KI-Anwendungen (wie Claude Desktop, Cursor IDE oder benutzerdefinierte Anwendungen), die eine Verbindung zu MCP-Servern herstellen, um auf deren Ressourcen zuzugreifen.

// Kernkomponenten von MCP

MCP-Server bieten drei Haupttypen von Funktionen:

1. Werkzeuge: Ausführbare Funktionen, die LLMs aufrufen können, um Aktionen auszuführen. Instruments können Datenbanken abfragen, APIs aufrufen, Berechnungen durchführen oder Workflows auslösen.
2. Ressourcen: Schreibgeschützte Daten, die MCP-Purchasers abrufen und als Kontext verwenden können. Ressourcen können Dateiinhalte, Konfigurationsdaten oder dynamisch generierte Inhalte sein.
3. Aufforderungen: Wiederverwendbare Nachrichtenvorlagen, die das LLM-Verhalten steuern. Eingabeaufforderungen bieten konsistente Anweisungen für mehrstufige Vorgänge oder spezielle Überlegungen.

# Was ist FastMCP?

FastMCP ist ein Excessive-Degree-Python-Framework, das den Prozess der Erstellung von MCP-Servern und -Purchasers vereinfacht. FastMCP wurde entwickelt, um Entwicklungsprobleme zu reduzieren und verfügt über die folgenden Eigenschaften:

• Dekoratorbasierte API: Python-Dekoratoren (@mcp.device, @mcp.useful resource, @mcp.immediate) Boilerplate beseitigen
• Typensicherheit: Vollständige Typhinweise und Validierung mit dem Typsystem von Python
• Async/Await-Unterstützung: Modernes asynchrones Python für Hochleistungsoperationen
• Mehrere Transporte: Unterstützung für stdio, HTTP, WebSocket und SSE
• Integrierte Assessments: Einfache Consumer-Server-Assessments ohne Komplexität von Unterprozessen
• Produktionsbereit: Funktionen wie Fehlerbehandlung, Protokollierung und Konfiguration für Produktionsbereitstellungen

// FastMCP-Philosophie

FastMCP basiert auf drei Grundprinzipien:

1. Abstraktionen auf hoher Ebene: Weniger Code und schnellere Entwicklungszyklen
2. Einfach: Durch die minimale Boilerplate können Sie sich auf die Funktionalität statt auf Protokolldetails konzentrieren
3. Pythonisch: Natürliche Python-Redewendungen machen es Python-Entwicklern vertraut

# Set up

Beginnen Sie mit der Set up von FastMCP und den erforderlichen Abhängigkeiten. Ich empfehle die Verwendung UV.

Wenn Sie kein UV haben, installieren Sie es mit pip:

Oder installieren Sie FastMCP direkt mit pip:

Stellen Sie sicher, dass FastMCP installiert ist:

python -c "from fastmcp import FastMCP; print('FastMCP put in efficiently')"

# Erstellen Sie Ihren ersten MCP-Server

Wir erstellen einen praktischen MCP-Server, der Instruments, Ressourcen und Eingabeaufforderungen demonstriert. Wir erstellen einen Rechnerserver, der mathematische Operationen, Konfigurationsressourcen und Anweisungsaufforderungen bereitstellt.

// Schritt 1: Einrichten der Projektstruktur

Wir müssen zunächst ein Projektverzeichnis erstellen und Ihre Umgebung initialisieren. Erstellen Sie einen Ordner für Ihr Projekt:

Navigieren Sie dann in Ihren Projektordner:

Initialisieren Sie Ihr Projekt mit den erforderlichen Dateien:

// Schritt 2: Erstellen des MCP-Servers

Unser Rechner-MCP-Server ist ein einfacher MCP-Server, der Instruments, Ressourcen und Eingabeaufforderungen demonstriert. Erstellen Sie in Ihrem Projektordner eine Datei mit dem Namen calculator_server.py und fügen Sie den folgenden Code hinzu.

import logging
import sys
from typing import Dict
from fastmcp import FastMCP

# Configure logging to stderr (vital for MCP protocol integrity)
logging.basicConfig(
    stage=logging.DEBUG,
    format="%(asctime)s - %(identify)s - %(levelname)s - %(message)s",
    stream=sys.stderr
)
logger = logging.getLogger(__name__)

# Create the FastMCP server occasion
mcp = FastMCP(identify="CalculatorServer")

Der Server importiert FastMCP und konfiguriert die Protokollierung stderr. Das MCP-Protokoll erfordert, dass alle Ausgaben, mit Ausnahme von Protokollnachrichten, an stderr weitergeleitet werden, um eine Beschädigung der Kommunikation zu vermeiden. Der FastMCP(identify="CalculatorServer") Aufruf erstellt die Serverinstanz. Dadurch wird die gesamte Protokollverwaltung automatisch abgewickelt.

Jetzt erstellen wir unsere Werkzeuge.

@mcp.device
def add(a: float, b: float) -> float:
    """
    Add two numbers collectively.
   
    Args:
        a: First quantity
        b: Second quantity
       
    Returns:
        Sum of a and b
    """
    attempt:
        end result = a + b
        logger.data(f"Addition carried out: {a} + {b} = {end result}")
        return end result
    besides TypeError as e:
        logger.error(f"Sort error in add: {e}")
        elevate ValueError(f"Invalid enter sorts: {e}")

@mcp.device
def subtract(a: float, b: float) -> float:
    """
    Subtract b from a.
   
    Args:
        a: First quantity (minuend)
        b: Second quantity (subtrahend)
       
    Returns:
        Distinction of a and b
    """
    attempt:
        end result = a - b
        logger.data(f"Subtraction carried out: {a} - {b} = {end result}")
        return end result
    besides TypeError as e:
        logger.error(f"Sort error in subtract: {e}")
        elevate ValueError(f"Invalid enter sorts: {e}")

Wir haben Funktionen für Addition und Subtraktion definiert. Beide sind in einen Attempt-Catch-Block eingeschlossen, um Wertfehler auszulösen, die Informationen zu protokollieren und das Ergebnis zurückzugeben.

@mcp.device
def multiply(a: float, b: float) -> float:
    """
    Multiply two numbers.
   
    Args:
        a: First quantity
        b: Second quantity
       
    Returns:
        Product of a and b
    """
    attempt:
        end result = a * b
        logger.data(f"Multiplication carried out: {a} * {b} = {end result}")
        return end result
    besides TypeError as e:
        logger.error(f"Sort error in multiply: {e}")
        elevate ValueError(f"Invalid enter sorts: {e}")

@mcp.device
def divide(a: float, b: float) -> float:
    """
    Divide a by b.
   
    Args:
        a: Dividend (numerator)
        b: Divisor (denominator)
       
    Returns:
        Quotient of a divided by b
       
    Raises:
        ValueError: If making an attempt to divide by zero
    """
    attempt:
        if b == 0:
            logger.warning(f"Division by zero tried: {a} / {b}")
            elevate ValueError("Can't divide by zero")
       
        end result = a / b
        logger.data(f"Division carried out: {a} / {b} = {end result}")
        return end result
    besides (TypeError, ZeroDivisionError) as e:
        logger.error(f"Error in divide: {e}")
        elevate ValueError(f"Division error: {e}")

Vier dekorierte Funktionen (@mcp.device) legen mathematische Operationen offen. Jedes Instrument beinhaltet:

• Geben Sie Hinweise für Parameter und Rückgabewerte ein
• Umfangreiche Dokumentationszeichenfolgen (MCP verwendet diese als Werkzeugbeschreibungen)
• Fehlerbehandlung mit Attempt-Besides-Blöcken
• Protokollierung zum Debuggen und Überwachen
• Eingabevalidierung

Kommen wir zum Aufbau von Ressourcen.

@mcp.useful resource("config://calculator/settings")
def get_settings() -> Dict:
    """
    Offers calculator configuration and obtainable operations.
   
    Returns:
        Dictionary containing calculator settings and metadata
    """
    logger.debug("Fetching calculator settings")
   
    return {
        "model": "1.0.0",
        "operations": ("add", "subtract", "multiply", "divide"),
        "precision": "IEEE 754 double precision",
        "max_value": 1.7976931348623157e+308,
        "min_value": -1.7976931348623157e+308,
        "supports_negative": True,
        "supports_decimals": True
    }

@mcp.useful resource("docs://calculator/information")
def get_guide() -> str:
    """
    Offers a person information for the calculator server.
   
    Returns:
        String containing utilization information and examples
    """
    logger.debug("Retrieving calculator information")

    information = """
       
    1. **add(a, b)**: Returns a + b
       Instance: add(5, 3) = 8
   
    2. **subtract(a, b)**: Returns a - b
       Instance: subtract(10, 4) = 6
   
    3. **multiply(a, b)**: Returns a * b
       Instance: multiply(7, 6) = 42
   
    4. **divide(a, b)**: Returns a / b
       Instance: divide(20, 4) = 5.0
   
    ## Error Dealing with
   
    - Division by zero will elevate a ValueError
    - Non-numeric inputs will elevate a ValueError
    - All inputs ought to be legitimate numbers (int or float)
   
    ## Precision
   
    The calculator makes use of IEEE 754 double precision floating-point arithmetic.
    Outcomes might include minor rounding errors for some operations.
    """
   
    return information

Zwei dekorierte Funktionen (@mcp.useful resource) stellen statische und dynamische Daten bereit:

• config://calculator/settings: Gibt Metadaten zum Rechner zurück
• docs://calculator/information: Gibt ein formatiertes Benutzerhandbuch zurück
• Das URI-Format unterscheidet Ressourcentypen (Konvention: sort://class/useful resource)

Lassen Sie uns unsere Eingabeaufforderungen erstellen.

@mcp.immediate
def calculate_expression(expression: str) -> str:
    """
    Offers directions for evaluating a mathematical expression.
    Args:
        expression: A mathematical expression to guage        
    Returns:
        Formatted immediate instructing the LLM methods to consider the expression
    """
    logger.debug(f"Producing calculation immediate for: {expression}")

    immediate = f"""
    Please consider the next mathematical expression step-by-step:
   
    Expression: {expression}
   
    Directions:
    1. Break down the expression into particular person operations
    2. Use the suitable calculator device for every operation
    3. Comply with order of operations (parentheses, multiplication/division, addition/subtraction)
    4. Present all intermediate steps
    5. Present the ultimate end result
   
    Obtainable instruments: add, subtract, multiply, divide
    """
   
    return immediate.strip()

Fügen Sie abschließend das Server-Startskript hinzu.

if __name__ == "__main__":
    logger.data("Beginning Calculator MCP Server...")
   
    attempt:
        # Run the server with stdio transport (default for Claude Desktop)
        mcp.run(transport="stdio")
    besides KeyboardInterrupt:
        logger.data("Server interrupted by person")
        sys.exit(0)
    besides Exception as e:
        logger.error(f"Deadly error: {e}", exc_info=True)
        sys.exit(1)

Der @mcp.immediate decorator erstellt Anweisungsvorlagen, die das LLM-Verhalten bei komplexen Aufgaben steuern.

Die hier aufgeführten Finest Practices für die Fehlerbehandlung sind:

• Spezifisches Abfangen von Ausnahmen (TypeError, ZeroDivisionError)
• Aussagekräftige Fehlermeldungen für Benutzer
• Detaillierte Protokollierung zum Debuggen
• Anmutige Fehlerausbreitung

// Schritt 3: Erstellen des MCP-Purchasers

In diesem Schritt zeigen wir, wie Sie mit dem oben erstellten Rechner-MCP-Server interagieren. Erstellen Sie eine neue Datei mit dem Namen calculator_client.py.

import asyncio
import logging
import sys
from typing import Any
from fastmcp import Consumer, FastMCP

logging.basicConfig(
    stage=logging.INFO,
    format="%(asctime)s - %(identify)s - %(levelname)s - %(message)s",
    stream=sys.stderr
)
logger = logging.getLogger(__name__)

async def primary():
    """
    Essential shopper operate demonstrating server interplay.
    """
   
    from calculator_server import mcp as server
   
    logger.data("Initializing Calculator Consumer...")

    attempt:
        async with Consumer(server) as shopper:
            logger.data("✓ Linked to Calculator Server")
           
            # DISCOVER CAPABILITIEs            
            print("n" + "="*60)
            print("1. DISCOVERING SERVER CAPABILITIES")
            print("="*60)
           
            # Listing obtainable instruments
            instruments = await shopper.list_tools()
            print(f"nAvailable Instruments ({len(instruments)}):")
            for device in instruments:
                print(f"  • {device.identify}: {device.description}")
           
            # Listing obtainable assets
            assets = await shopper.list_resources()
            print(f"nAvailable Sources ({len(assets)}):")
            for useful resource in assets:
                print(f"  • {useful resource.uri}: {useful resource.identify or useful resource.uri}")
           
            # Listing obtainable prompts
            prompts = await shopper.list_prompts()
            print(f"nAvailable Prompts ({len(prompts)}):")
            for immediate in prompts:
                print(f"  • {immediate.identify}: {immediate.description}")
           
            # CALL TOOLS
           
            print("n" + "="*60)
            print("2. CALLING TOOLS")
            print("="*60)
           
            # Easy addition
            print("nTest 1: Including 15 + 27")
            end result = await shopper.call_tool("add", {"a": 15, "b": 27})
            result_value = extract_tool_result(end result)
            print(f"  Consequence: 15 + 27 = {result_value}")
           
            # Division with error dealing with
            print("nTest 2: Dividing 100 / 5")
            end result = await shopper.call_tool("divide", {"a": 100, "b": 5})
            result_value = extract_tool_result(end result)
            print(f"  Consequence: 100 / 5 = {result_value}")
           
            # Error case: division by zero
            print("nTest 3: Division by Zero (Error Dealing with)")
            attempt:
                end result = await shopper.call_tool("divide", {"a": 10, "b": 0})
                print(f"  Sudden success: {end result}")
            besides Exception as e:
                print(f"  ✓ Error caught appropriately: {str(e)}")
           
            # READ RESOURCES
            print("n" + "="*60)
            print("3. READING RESOURCES")
            print("="*60)
           
            # Learn settings useful resource
            print("nFetching Calculator Settings...")
            settings_resource = await shopper.read_resource("config://calculator/settings")
            print(f"  Model: {settings_resource(0).textual content}")
           
            # Learn information useful resource
            print("nFetching Calculator Information...")
            guide_resource = await shopper.read_resource("docs://calculator/information")
            # Print first 200 characters of information
            guide_text = guide_resource(0).textual content(:200) + "..."
            print(f"  {guide_text}")
           
            # CHAINING OPERATIONS
           
            print("n" + "="*60)
            print("4. CHAINING MULTIPLE OPERATIONS")
            print("="*60)
           
            # Calculate: (10 + 5) * 3 - 7
            print("nCalculating: (10 + 5) * 3 - 7")
           
            # Step 1: Add
            print("  Step 1: Add 10 + 5")
            add_result = await shopper.call_tool("add", {"a": 10, "b": 5})
            step1 = extract_tool_result(add_result)
            print(f"    Consequence: {step1}")
           
            # Step 2: Multiply
            print("  Step 2: Multiply 15 * 3")
            mult_result = await shopper.call_tool("multiply", {"a": step1, "b": 3})
            step2 = extract_tool_result(mult_result)
            print(f"    Consequence: {step2}")
           
            # Step 3: Subtract
            print("  Step 3: Subtract 45 - 7")
            final_result = await shopper.call_tool("subtract", {"a": step2, "b": 7})
            ultimate = extract_tool_result(final_result)
            print(f"    Last Consequence: {ultimate}")
           
            # GET PROMPT TEMPLATE
           
            print("n" + "="*60)
            print("5. USING PROMPT TEMPLATES")
            print("="*60)
           
            expression = "25 * 4 + 10 / 2"
            print(f"nPrompt Template for: {expression}")
            prompt_response = await shopper.get_prompt(
                "calculate_expression",
                {"expression": expression}
            )
            print(f"  Template:n{prompt_response.messages(0).content material.textual content}")
           
            logger.data("✓ Consumer operations accomplished efficiently")
   
    besides Exception as e:
        logger.error(f"Consumer error: {e}", exc_info=True)
        sys.exit(1)

Aus dem obigen Code verwendet der Consumer async with Consumer(server) für sicheres Verbindungsmanagement. Dadurch wird der Verbindungsaufbau und die Verbindungsbereinigung automatisch durchgeführt.

Wir benötigen auch eine Hilfsfunktion, um die Ergebnisse zu verarbeiten.

def extract_tool_result(response: Any) -> Any:
    """
    Extract the precise end result worth from a device response.
   
    MCP wraps leads to content material objects, this helper unwraps them.
    """
    attempt:
        if hasattr(response, 'content material') and response.content material:
            content material = response.content material(0)
            # Want express textual content content material when obtainable (TextContent)
            if hasattr(content material, 'textual content') and content material.textual content just isn't None:
                # If the textual content is JSON, attempt to parse and extract a `end result` area
                import json as _json
                text_val = content material.textual content
                attempt:
                    parsed_text = _json.hundreds(text_val)
                    # If JSON comprises a end result area, return it
                    if isinstance(parsed_text, dict) and 'end result' in parsed_text:
                        return parsed_text.get('end result')
                    return parsed_text
                besides _json.JSONDecodeError:
                    # Attempt to convert plain textual content to quantity
                    attempt:
                        if '.' in text_val:
                            return float(text_val)
                        return int(text_val)
                    besides Exception:
                        return text_val

            # Attempt to extract JSON end result by way of mannequin `.json()` or dict-like `.json`
            if hasattr(content material, 'json'):
                attempt:
                    if callable(content material.json):
                        json_str = content material.json()
                        import json as _json
                        attempt:
                            parsed = _json.hundreds(json_str)
                        besides _json.JSONDecodeError:
                            return json_str
                    else:
                        parsed = content material.json

                    # If parsed is a dict, attempt widespread shapes
                    if isinstance(parsed, dict):
                        # If nested end result exists
                        if 'end result' in parsed:
                            res = parsed.get('end result')
                        elif 'textual content' in parsed:
                            res = parsed.get('textual content')
                        else:
                            res = parsed

                        # If res is str that appears like a quantity, convert
                        if isinstance(res, str):
                            attempt:
                                if '.' in res:
                                    return float(res)
                                return int(res)
                            besides Exception:
                                return res
                        return res

                    return parsed
                besides Exception:
                    cross
        return response
    besides Exception as e:
        logger.warning(f"Couldn't extract end result: {e}")
        return response


if __name__ == "__main__":
    logger.data("Calculator Consumer Beginning...")
    asyncio.run(primary())

Wenn Sie sich den obigen Code ansehen, listet der Consumer vor der Verwendung von Instruments die verfügbaren Funktionen auf. Der await shopper.list_tools() Ruft alle Instrument-Metadaten ab, einschließlich Beschreibungen. Der await shopper.list_resources() entdeckt verfügbare Ressourcen. Schließlich die await shopper.list_prompts() finden Sie verfügbare Eingabeaufforderungsvorlagen.

Der await shopper.call_tool() Methode führt Folgendes aus:

• Übernimmt den Werkzeugnamen und die Parameter als Wörterbuch
• Gibt ein umschlossenes Antwortobjekt zurück, das das Ergebnis enthält
• Integriert sich in die Fehlerbehandlung für Werkzeugfehler

Bei der Ergebnisextraktion wird die extract_tool_result() Die Hilfsfunktion entpackt das MCP-Antwortformat, um den tatsächlichen Wert zu erhalten, und verarbeitet sowohl JSON- als auch Textantworten.

Die oben gezeigten Verkettungsoperationen veranschaulichen, wie die Ausgabe eines Instruments als Eingabe für ein anderes verwendet wird, wodurch komplexe Berechnungen über mehrere Toolaufrufe hinweg möglich sind.

Schließlich fängt die Fehlerbehandlung Werkzeugfehler ab (z. B. Division durch Null) und protokolliert sie ordnungsgemäß, ohne dass es zu Abstürzen kommt.

// Schritt 4: Ausführen des Servers und Purchasers

Sie werden zwei Terminals öffnen. Auf Terminal 1 starten Sie den Server:

python calculator_server.py

Sie sollten Folgendes sehen:

Bild vom Autor

Führen Sie auf Terminal 2 den Consumer aus:

python calculator_client.py

Die Ausgabe zeigt:

Bild vom Autor

# Erweiterte Muster mit FastMCP

Während unser Taschenrechner-Beispiel grundlegende Logik verwendet, ist FastMCP darauf ausgelegt, komplexe, produktionsreife Szenarien zu bewältigen. Wenn Sie Ihre MCP-Server skalieren, können Sie Folgendes nutzen:

• Asynchrone Operationen: Verwenden async def für Instruments, die I/O-gebundene Aufgaben wie Datenbankabfragen oder API-Aufrufe ausführen
• Dynamische Ressourcen: Ressourcen können Argumente akzeptieren (z. B. useful resource://customers/{user_id}), um bestimmte Datenpunkte im laufenden Betrieb abzurufen
• Komplexe Typvalidierung: Verwenden Sie Pydantic-Modelle oder komplexe Python-Typhinweise, um sicherzustellen, dass das LLM Daten genau in dem Format sendet, das Ihr Backend benötigt
• Benutzerdefinierte Transporte: Während wir verwendet haben stdioFastMCP unterstützt auch SSE (Server-Despatched Occasions) für webbasierte Integrationen und benutzerdefinierte UI-Instruments

# Abschluss

FastMCP schließt die Lücke zwischen dem komplexen Mannequin Context Protocol und der sauberen, dekoratorbasierten Entwicklererfahrung, die Python-Programmierer erwarten. Durch den Wegfall der mit JSON-RPC 2.0 und der manuellen Transportverwaltung verbundenen Standardfunktionen können Sie sich auf das Wesentliche konzentrieren: Entwicklung der Instruments, die LLMs leistungsfähiger machen.

In diesem Tutorial haben wir Folgendes behandelt:

1. Die Kernarchitektur von MCP (Server vs. Purchasers)
2. So definieren Sie Werkzeuge für Taten, Ressourcen für Daten und Aufforderungen für Anweisungen
3. So erstellen Sie einen funktionalen Consumer zum Testen und Verketten Ihrer Serverlogik

Unabhängig davon, ob Sie ein einfaches Dienstprogramm oder eine komplexe Datenorchestrierungsschicht erstellen, bietet FastMCP den „pythonischsten“ Weg zu einem produktionsbereiten Agenten-Ökosystem.

Was werden Sie als nächstes bauen? Schauen Sie sich das an FastMCP-Dokumentation um erweiterte Bereitstellungsstrategien und UI-Integrationen zu erkunden.

Shittu Olumid ist ein Software program-Ingenieur und technischer Autor, der sich leidenschaftlich dafür einsetzt, modernste Technologien zu nutzen, um fesselnde Erzählungen zu erschaffen, mit einem scharfen Blick fürs Element und einem Gespür für die Vereinfachung komplexer Konzepte. Sie können Shittu auch auf finden Twitter.

Bild des Autors

MCPs (Modellkontextprotokolle) werden schnell zum Rückgrat der modernen KI -Werkzeuge. Große Namen wie Hugging Face und Meta führen jetzt Hackathons aus, bei denen die Teilnehmer MCP -Server, Kunden und Plugins bauen und zeigen, wie heiß dieser Raum gerade ist.

Was genau ist ein MCP -Server und ein Shopper?

• MCP -Server sind leichte Programme oder APIs, die reale Instruments wie Datenbanken, Dateisysteme oder Webdienste für KI-Modelle aussetzen. Sie fungieren als Brücken und lassen KI -Agenten sicher und effizient mit externen Systemen interagieren.
• MCP -Kunden sind Anwendungen (wie IDEs, Chatbots oder Desktop -Apps), die eine Verbindung zu diesen Servern herstellen, mit denen Benutzer oder KI -Agenten über eine einzige Oberfläche auf Tausende von Instruments und Diensten zugreifen können.

In diesem Artikel werden wir die High 7 MCP-Kunden überprüfen, mit denen Sie Tausende von Open-Supply-MCP-Servern erleben können. Auch wenn Sie keine vorherigen Erfahrung haben, ist das Setup normalerweise so einfach wie das Hinzufügen einer Zeile zur Konfigurationsdatei Ihres Shoppers.

1. Claude Desktop

Ich benutze es wirklich gerne Claude Desktop Denn es macht es einfach, auf dynamische Weise mit Code zu sehen und zu interagieren. Die Integration in MCP -Server hilft mir, neue Themen effizient zu debuggen und zu erforschen. Ich verwende regelmäßig Claude -Desktop und finde es sehr genau, verfügbare Instruments zu erkennen und sie auszuführen, um hilfreiche Antworten zu generieren.

Eine der besten Funktionen ist, wie nahtlos es mit lokal konfigurierten MCP -Servern funktioniert. Wenn Sie die Anwendung starten, startet sie automatisch alle konfigurierten MCP -Server, sodass Sie vom Desktop sofort auf leistungsstarke Instruments zugreifen können.

2. Cursor ai

Wenn Sie verwenden Cursor Für die Codierung oder Bearbeitung ist die Integration mehrerer MCP -Server für die Steigerung seiner Funktionen von wesentlicher Bedeutung. Während Cursor AI bereits eine Vielzahl von integrierten Agenten und Instruments bietet, kann das Hinzufügen von maßgeschneiderten MCP-Servern und APIs Ihren Entwicklungsworkflow auf die nächste Ebene bringen, indem Sie viele Aufgaben automatisieren. Im Gegensatz zum Claude -Desktop unterstützt der Cursor AI das SSE -Protokoll und erleichtert das Zugriff auf und konfiguriert gehostete MCPs.

3. Claude Code

In dem Second, in dem ich es versuchte Claude -Code Mit Claude Opus 4 battle ich beeindruckt, wie intestine es Ihre Anforderungen und Ihren Code versteht und quick fehlerfreie Ergebnisse erzielt. Selbst wenn es ein Downside gibt, kann Claude Code es mithilfe seines Agentenmodus und integrierten Instruments beheben. Es ist zutiefst bewusst, dass Ihre Codebasis Änderungen über mehrere Dateien hinweg vornehmen und sich Ihren Codierungsstandards anpassen kann.

Claude Code unterstützt auch die MCP -Server -Integration, ähnlich wie Cursor AI. Sobald Sie Ihren MCP -Server konfiguriert haben, kann Claude Code ihn bei Bedarf automatisch aufrufen.

4. Windsurf

WindsurfWie Cursor AI unterstützt das SSE -Protokoll und bietet eine ähnliche Entwicklungserfahrung. Es verfügt über einen integrierten MCP-Plugin-Retailer, in dem Sie Ihre eigenen MCP-Server-Plugins problemlos suchen, installieren oder hinzufügen können.

Wenn Sie das von Ihnen benötigte Plugin nicht finden können, können Sie es manuell hinzufügen, indem Sie die Datei mcp_config.json bearbeiten. Offizielle MCP -Plugins sind mit einem blauen Checkmark markiert, was darauf hinweist, dass sie von der Muttergesellschaftsfirma hergestellt werden.

Unter allen oben genannten MCP -Kunden bietet Windsurf mehr Funktionen und Einstellungen und ist auch billiger als die anderen.

5. Cline

Cline ist eine leistungsstarke VS -Code -Erweiterung, die als autonomer Coding -Agent fungiert und Codegenerierung, Debuggen und nahtlose MCP -Integration bietet, um seine Funktionen zu erweitern. Es ist besonders beliebt bei Benutzern, die sich in OpenRouter integrieren möchten, um auf kostenlose Modelle zuzugreifen und kostenlos ein erstklassiges KI-Entwicklungserlebnis zu genießen. Mit Cline können Sie Dateien erstellen und bearbeiten, Befehle ausführen, den Browser verwenden und sogar benutzerdefinierte MCP -Instruments erstellen, die auf Ihren Workflow zugeschnitten sind, alle direkt von Ihrer IDE.

6. Weiter

Weitermachen ist eine Open-Supply-IDE-Erweiterung für VS-Code und Jetbrains, die Codegenerierung, automatische Vervollständigung, Chat und Code-Bearbeitung von In-Editor bietet und quick alle Funktionen in High-AI-Code-Redakteuren wie Cursor und Windsurf bietet. Es unterstützt auch die MCP -Integration, die Hub -Assistenten unter Verwendung von MCPServers -Blöcken hinzugefügt werden kann. Wenn Sie mehr Anpassungen benötigen, können Sie Ihre eigenen Assistenten erstellen oder eine Verbindung zu verschiedenen Modellen und Plugins herstellen.

7. Librechat

Librechat ist eine kostenlose Open-Supply-Chatgpt-Different, mit der Sie eine breite Palette von AI-Modelsanbietern herstellen können, darunter OpenAI, Anthropic, Google und sogar lokale Modelle über OLLAMA.

Librechat unterstützt auch die MCP -Integration und ermöglicht es Ihnen, MCPServers für die dynamische Interaktion mit verschiedenen speziellen Instruments und Servern zu konfigurieren. Mit diesem modularen Setup können die Funktionen von Librechat einfach erweitert werden, indem Serverkonfigurationen einfach hinzugefügt oder bearbeitet werden.

Letzte Gedanken

Das Hinzufügen von MCP-Help ist ein Sport-Changer, insbesondere mit offiziellen Servern von Anbietern wie Mem0, Anthropic, Exa und anderen. Diese offiziellen MCPs arbeiten zuverlässig und sind mit starken Sicherheit und Privatsphäre ausgelegt. Noch aufregender ist, dass Sie mit nur wenigen Code -Zeilen problemlos Ihre eigenen MCP -Server vor Ort erstellen können, und sie werden nahtlos außerhalb der Field arbeiten.

Wenn Sie neu bei MCPS sind, empfehle ich dringend, mit Claude Desktop zu beginnen und eine der einfachen Integrationen auszuprobieren, für die keine API -Schlüssel erforderlich sind.

Überprüfen Sie meine Führer zum Erstellen und Integrieren von MCP -Servern:

Abid Ali Awan (@1abidaliawan) ist ein zertifizierter Datenwissenschaftler, der es liebt, maschinelles Lernenmodelle zu bauen. Derzeit konzentriert er sich auf die Erstellung von Inhalten und das Schreiben von technischen Blogs über maschinelles Lernen und Datenwissenschaftstechnologien. Abid hat einen Grasp -Abschluss in Technologiemanagement und einen Bachelor -Abschluss in Telekommunikationstechnik. Seine Imaginative and prescient ist es, ein KI -Produkt zu bauen, das ein Diagramm neuronales Netzwerk für Schüler mit psychische Erkrankungen mit kämpfender Krankheiten unterhält.