Eine Einführung in Distant -Modellkontext -Protokollserver

Ich habe zuletzt im Dezember 2024 über das Modellkontextprotokoll (MCP) geschrieben, kurz vor dem exponentiellen Wachstum des Themas in das, was es heute ist. Ich erinnere mich, dass ich zu der Zeit gedacht habe, dass eines der wichtigsten Dinge, die ich für MCP passieren musste, um die Technologie zu einem Sport Changer zu machen, die Fähigkeit für MCP-Kunden conflict, auf nicht lokale MCP-Server zuzugreifen. Das passiert natürlich schon, aber was ist, wenn Sie ein Stück dieser Aktion wollen? Wie schreibt man einen Distant -MCP -Server, der nützliche Instruments dafür herstellt, ihn testen?Dann können Sie sie beispielsweise in der Cloud bereitstellen, damit jeder auf die Instruments zugreifen kann, die er von einem unterstützten Kunden überall auf der Welt ausgesetzt ist?

Ich werde Ihnen zeigen, wie man all diese Dinge in diesem Artikel macht.

Eine kurze Zusammenfassung darüber, was ein MCP -Server ist

Es gibt Dutzende von Definitionen für das, was ein MCP -Server ist. Meiner Ansicht nach ist ein MCP-Server mit MCP-fähigen Shoppers wie Cursor und Claude-Code wahrscheinlich ein bisschen übereinfacher Vereinfachung, um nützliche Funktionen zu nennen, die der MCP-Server enthält.
Wie unterscheidet sich das von Ihnen, wenn Sie nur eine Reihe wertvoller Instruments schreiben und in Ihrem Code anrufen?

Nun, der Schlüssel ist das Du bist Schreiben dieser Werkzeuge. Was ist mit dem potenziellen Universum von Werkzeugen, die existieren, das? jemand anderes hat geschrieben? Ich bin sicher, Sie haben den Ausdruck gehört „… dafür gibt es eine App“. In nicht allzu ferner Zukunft könnte das werden „… Dafür gibt es einen MCP -Server“OK, nicht so bissig, sondern genauso bahnbrechend.

Bisher wurde die überwiegende Mehrheit der MCP -Server mit dem Stdio -Transporttyp geschrieben. Dies bedeutet, dass die Verantwortung eingeschaltet ist Du So hosten Sie den Server auf Ihrem lokalen System. Das kann manchmal schwierig und fehleranfällig sein. Darüber hinaus können Sie nur auf diesen Server zugreifen. Und hier kommen Distant (oder streamable HTTP) MCP -Server zu sich. Aus der Ferne müssen Sie nur die URL des Servers und die Namen der Instruments kennenlernen, und Sie sind in Sekundenschnelle mit ihm ausgeführt.

Wenn Sie additionally etwas geschrieben haben, das andere als wirklich hilfreich empfinden, sollten Sie einen Distant -MCP -Server davon erstellen, es in der Cloud hosten und andere auch verwenden lassen?

Okay, lass uns das machen.

Mein Setup

Ich werde den Code für den MCP -Server und seine Instruments mithilfe von Home windows und Microsoft Visible Studio Code entwickeln. Ich werde Git Bash für meine Befehlszeile verwenden, da sie mit einigen praktischen Versorgungsunternehmen ausgestattet ist, die ich verwenden werde, wie z. Locken Und sed. Sie müssen auch installieren Node.js und die UV Python Package deal Utility. Wenn Sie den fertigen MCP -Server in der Cloud bereitstellen möchten, müssen Sie Ihren Code auch auf GitHub speichern, sodass Sie ein Konto dafür benötigen.

Das erste, was Sie tun sollten, ist, ein neues Projekt für Ihren Code usw. zu initialisieren. Verwenden Sie die UV Werkzeug mit der Init -Flagge dafür. Als nächstes fügen wir eine Umgebung hinzu, wechseln dorthin und fügen alle externen Bibliotheken hinzu, die unser Code verwendet.

$ uv init remote-mcp
Initialized mission `remote-mcp` at `/dwelling/tom/initiatives/remote-mcp`
$ cd remote-mcp
$ ls -al
whole 28
drwxr-xr-x 3 tom tom 4096 Jun 23 17:42 .
drwxr-xr-x 14 tom tom 4096 Jun 23 17:42 ..
drwxr-xr-x 7 tom tom 4096 Jun 23 17:42 .git
-rw-r--r-- 1 tom tom 109 Jun 23 17:42 .gitignore
-rw-r--r-- 1 tom tom 5 Jun 23 17:42 .python-version
-rw-r--r-- 1 tom tom 0 Jun 23 17:42 README.md
-rw-r--r-- 1 tom tom 88 Jun 23 17:42 predominant.py
-rw-r--r-- 1 tom tom 156 Jun 23 17:42 pyproject.toml

$ uv venv && supply .venv/bin/activate
# Now, set up the libraries we are going to use.
(remote-mcp) $ uv add fastapi 'uvicorn(commonplace)' mcp-server requests yfinance python-dotenv

Was wir entwickeln werden

Wir werden einen MCP -Server und zwei verschiedene Instruments entwickeln, mit denen unser MCP -Server verwendet werden kann. Der erste wird ein Nobelpreisprüfer sein. Sie bieten ein Jahr, z. B. 1935, und ein Fach, z. B. Physik und der MCP -Server werden Informationen darüber zurückgeben, wer in diesem Jahr den Preis in diesem Jahr gewonnen hat. Das zweite Device gibt die maximal aufgezeichnete Temperatur für eine Stadt in der vergangenen Woche zurück

Zunächst einmal codieren wir unsere beiden Instruments und testen sie lokal. Als nächstes werden wir die Instruments in einen MCP -Server einbeziehen, der lokal ausgeführt wird, und diese Einrichtung testen. Wenn es wie erwartet funktioniert, können wir den MCP -Server und seine Instruments auf einem Distant -Cloud -Server bereitstellen und überprüfen, ob er weiterhin korrekt funktioniert.

Code Beispiel 1 – Nobelpreisinformationen erhalten

Die Dienste der Nobelpreis -Web site sind im Rahmen der Artistic Commons Zero -Lizenz lizenziert. Sie können die Particulars mit dem folgenden Hyperlink sehen:

https://www.nobelprize.org/about/terms-of-use-for-api-nobelprize-org-anda-nobelprize-org

Hier ist die Basisfunktion, die wir verwenden werden. Öffnen Sie Ihren Code -Editor und speichern Sie diesen Inhalt in einer Datei mit dem Namen prize_tool.py.

import requests
import os
import io
import csv

# from mcp.server.fastmcp import FastMCP
strive:
    from mcp.server.fastmcp import FastMCP
besides ModuleNotFoundError:
    # Strive importing from a neighborhood path if operating domestically
    import sys
    sys.path.append(os.path.abspath(os.path.be part of(os.path.dirname(__file__), '..')))
    from fastmcp import FastMCP

mcp = FastMCP(identify="nobelChecker",stateless_http=True)

@mcp.instrument()
def nobel_checker(yr, topic):
    """
    Finds the Nobel Prize winner(s) for a given yr and topic utilizing the Nobel Prize API.

    Args:
        yr (int): The yr of the prize.
        topic (str): The class of the prize (e.g., 'physics', 'chemistry', 'peace').

    Returns:
        checklist: An inventory of strings, the place every string is the total identify of a winner.
              Returns an empty checklist if no prize was awarded or if an error occurred.
    """
    BASE_URL = "http://api.nobelprize.org/v1/prize.csv"
    
    # Put together the parameters for the request, changing topic to lowercase
    # to match the API's expectation.
    params = {
        'yr': yr,
        'class': topic.decrease()
    }
    
    strive:
        # Make the request utilizing the protected 'params' argument
        response = requests.get(BASE_URL, params=params)
        
        # It will increase an exception for unhealthy standing codes (like 404 or 500)
        response.raise_for_status()

        # If the API returns no knowledge (e.g., no prize that yr), the textual content will
        # usually simply be the header row. We test if there's a couple of line.
        if len(response.textual content.splitlines()) <= 1:
            return () # No winners discovered

        # Use io.StringIO to deal with the response textual content (a string) like a file
        csv_file = io.StringIO(response.textual content)
        
        # Use DictReader to simply entry columns by identify
        reader = csv.DictReader(csv_file)
        
        winners = ()
        for row in reader:
            full_name = f"{row('firstname')} {row('surname')}"
            winners.append(full_name)
            
        return winners

    besides requests.exceptions.RequestException as e:
        print(f"An error occurred throughout the API request: {e}")
        return () # Return an empty checklist on community or HTTP errors

if __name__ == "__main__":
   knowledge =  nobel_checker(1921,"Physics")
   print(knowledge)

Dieses Skript definiert ein kleines MCP-Device „Nobel-Checker“ (Modellkontextprotokoll), das entweder lokal oder in einem FastMCP-Server ausgeführt werden kann. Nach dem Versuch zu importieren FastMCP von der mcp.server Paket und zurück auf ein Geschwister zurückfallen fastmcp Modul, wenn dieser Import fehlschlägt. Es erstellt dann eine MCP -Instanz mit dem Namen Nobelchecker Mit dem tatsächlichen Flag für staatseless_http = true, was bedeutet, dass FastMCP automatisch einen einfachen HTTP-Endpunkt für One-Shot-Anrufe enthüllt. Die dekorierte Funktion nobel_checker wird ein MCP -Device. Wann aufrufenED, es baut eine Abfrage in die Relaxation -API mit dem angegebenen Jahr und dem Thema auf und gibt die Namen des Preisträgers für dieses Jahr und das Thema zurück (oder eine hilfreiche Nachricht, wenn nicht).

Wenn wir den obigen Code lokal ausführen, erhalten wir eine ähnliche Ausgabe wie die folgenden, was darauf hinweist, dass die Funktion korrekt funktioniert und ihre beabsichtigte Aufgabe ausführt.

('Albert Einstein')

Code Beispiel 2 – Erhalten Sie Informationen zur Stadttemperatur

Für unsere zweite Basisfunktion schreiben wir ein Device, das in der letzten Woche die höchste Temperatur für eine Stadt zurückgibt. Die Wetterdaten werden von open-meteo.com bereitgestellt. Auf ihrer Lizenzseite (“https://open-meteo.com/en/license), es heißt,,

„API -Daten werden unter angeboten Attribution 4.0 Worldwide (CC von 4.0)

Sie sind frei zu Aktie: kopieren und verteilt das Materials in einem beliebigen Medium oder Format und verteilt anpassen: Remix, transformieren und bauen auf dem Materials auf. “

Ich habe die korrekte Zuschreibung und den Verknüpfung zu ihrer Lizenz gegeben, die die Bedingungen ihrer Lizenz erfüllt.

Erstellen Sie die Python -Datei temp_tool.py und geben Sie diesen Code ein.

# temp_tool.py

from mcp.server.fastmcp import FastMCP

mcp = FastMCP(identify="stockChecker", stateless_http=True)

import requests
from datetime import datetime, timedelta

# This helper perform could be reused. It isn't tied to a particular API supplier.
def get_coords_for_city(city_name):
    """
    Converts a metropolis identify to latitude and longitude utilizing a free, open geocoding service.
    """
    # Utilizing Open-Meteo's geocoding, which can be free and requires no key.
    GEO_URL = "https://geocoding-api.open-meteo.com/v1/search"
    params = {'identify': city_name, 'depend': 1, 'language': 'en', 'format': 'json'}
    
    strive:
        response = requests.get(GEO_URL, params=params)
        response.raise_for_status()
        knowledge = response.json()
        
        if not knowledge.get('outcomes'):
            print(f"Error: Metropolis '{city_name}' not discovered.")
            return None, None
            
        # Extract the very first end result
        location = knowledge('outcomes')(0)
        return location('latitude'), location('longitude')
        
    besides requests.exceptions.RequestException as e:
        print(f"API request error throughout geocoding: {e}")
        return None, None

@mcp.instrument()
def get_historical_weekly_high(city_name):
    """
    Will get the best temperature for a metropolis over the earlier 7 days utilizing the
    commercially-friendly Open-Meteo API.

    Args:
        city_name (str): The identify of town (e.g., "New York", "London").

    Returns:
        float: The very best temperature in Fahrenheit from the interval, or None if an error happens.
    """
    # 1. Get the coordinates for town
    lat, lon = get_coords_for_city(city_name)
    if lat is None or lon is None:
        return None # Exit if metropolis wasn't discovered
        
    # 2. Calculate the date vary for the final week
    end_date = datetime.now() - timedelta(days=1)
    start_date = datetime.now() - timedelta(days=7)
    start_date_str = start_date.strftime('%Y-%m-%d')
    end_date_str = end_date.strftime('%Y-%m-%d')

    # 3. Put together the API request for the Historic API
    HISTORICAL_URL = "https://archive-api.open-meteo.com/v1/era5"
    params = {
        'latitude': lat,
        'longitude': lon,
        'start_date': start_date_str,
        'end_date': end_date_str,
        'day by day': 'temperature_2m_max', # The particular variable for day by day max temp
        'temperature_unit': 'fahrenheit' # This API handles items appropriately
    }
    
    strive:
        print(f"Fetching historic weekly max temp for {city_name.title()}...")
        response = requests.get(HISTORICAL_URL, params=params)
        response.raise_for_status()
        knowledge = response.json()
        
        daily_data = knowledge.get('day by day', {})
        max_temps = daily_data.get('temperature_2m_max', ())
        
        if not max_temps:
            print("Couldn't discover historic temperature knowledge within the response.")
            return None
            
        # 4. Discover the one highest temperature from the checklist of day by day highs
        highest_temp = max(max_temps)
        
        return spherical(highest_temp, 1)

    besides requests.exceptions.RequestException as e:
        print(f"API request error throughout historic fetch: {e}")
        return None

if __name__ == "__main__":
   knowledge =  get_historical_weekly_high("New York")
   print(knowledge)

Diese Funktion nimmt einen Stadtnamen auf und gibt die höchste Temperatur der Stadt für die letzte Woche zurück.

Hier ist eine typische Ausgabe, wenn Sie lokal ausgeführt werden.

Fetching historic weekly max temp for New York...
104.3

Erstellen unseres MCP -Servers

Nachdem wir gezeigt haben, dass unsere Funktionen funktionieren, lassen wir sie in einen MCP -Server einbeziehen und das lokal ausführen. Hier ist der Servercode, den Sie benötigen.

# mcp_server.py

import contextlib
from fastapi import FastAPI
from temp_tool import mcp as temp_mcp
from prize_tool import mcp as prize_mcp
import os
from dotenv import load_dotenv

load_dotenv()

# Create a mixed lifespan to handle each session managers
@contextlib.asynccontextmanager
async def lifespan(app: FastAPI):
    async with contextlib.AsyncExitStack() as stack:
        await stack.enter_async_context(temp_mcp.session_manager.run())
        await stack.enter_async_context(prize_mcp.session_manager.run())
        yield


app = FastAPI(lifespan=lifespan)
app.mount("/temp", temp_mcp.streamable_http_app())
app.mount("/prize", prize_mcp.streamable_http_app())

PORT = int(os.getenv("PORT", "10000"))

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=PORT)

Die einzigen Änderungen an unseren ursprünglichen Prize_tool- und temp_tool -Codebasen bestehen darin, die drei Zeilen am unteren Rand der jeweiligen Testen zu löschen. Entfernen Sie diese von beiden.

if __name__ == "__main__":
    knowledge = nobel_checker(1921,"Physics")
    print(knowledge)

and ...

if __name__ == "__main__":
    knowledge = get_historical_weekly_high("New York")
    print(knowledge)

Ausführen des MCP -Servers lokal ausführen

Geben Sie zum Ausführen unseres Servers den folgenden Befehl in ein Befehlszeilenterminal ein.

$ uvicorn mcp_server:app --reload --port 10000
$ # You may as well use python mcp_server.py --reload --port 10000
$ #
INFO: Will look ahead to adjustments in these directories: ('C:Customersthomainitiativesremote-mcpremote-mcp')
INFO: Uvicorn operating on http://127.0.0.1:10000 (Press CTRL+C to give up)
INFO: Began reloader course of (3308) utilizing WatchFiles
INFO: Began server course of (38428)
INFO: Ready for software startup.
(06/25/25 08:36:22) INFO StreamableHTTP session supervisor began streamable_http_manager.py:109
INFO StreamableHTTP session supervisor began streamable_http_manager.py:109
INFO: Utility startup full.

Testen Sie unseren MCP -Server lokal

Dafür können wir ein Gitbash -Befehlsterminal und ein Curl verwenden. Stellen Sie sicher, dass Ihr Server zuerst in Betrieb ist. Versuchen wir zuerst unser Temperaturprüfwerkzeug. Die Ausgabe kann immer postverarbeitet werden, um genau den gewünschten Inhalt in einem benutzerfreundlicheren Format herauszubringen.

$ curl -sN -H 'Content material-Kind: software/json' -H 'Settle for: software/json, textual content/event-stream' -d '{"jsonrpc":"2.0","id":1,"methodology":"instruments/name","params":{"identify":"get_historical_weekly_high","arguments":{"city_name":"New York"}}}' http://localhost:10000/temp/mcp/ | sed -n '/^knowledge:/{s/^knowledge: //;p}'


{"jsonrpc":"2.0","id":1,"end result":{"content material":({"sort":"textual content","textual content":"104.3"}),"isError":false}}

Dies zeigt, dass die maximale Temperatur in NY in der letzten Woche 104,3 Fahrenheit betrug.

Und jetzt können wir das Preis -Checker -Device testen.

$ curl -sN -H 'Content material-Kind: software/json' -H 'Settle for: software/json, textual content/event-stream' -d '{"jsonrpc":"2.0","id":1,"methodology":"instruments/name","params":{"identify":"nobel_checker","arguments":{"yr":1921,"class":"Physics"}}}' http://localhost:10000/prize/mcp/ | sed -n '/^knowledge:/{s/^knowledge: //;p}' 

{"jsonrpc":"2.0","id":1,"end result":{"content material":({"sort":"textual content","textual content":"Albert Einstein"}),"isError":false}}

Albert Einstein gewann 1921 den Nobelpreis für Physik.

Bereitstellung unseres MCP -Servers distant

Jetzt, da wir mit unserem Code zufrieden sind und dass der MCP -Server wie erwartet lokal arbeitet, besteht die nächste Section darin, ihn aus der Ferne bereitzustellen und jedem auf der Welt zu ermöglichen, ihn zu verwenden. Es gibt einige Möglichkeiten, dies zu tun, aber vielleicht ist es am einfachsten (und anfangs am billigsten), einen Service wie Machen.

Render ist eine moderne Cloud-Internet hosting-Plattform-wie eine einfachere Different zu AWS, Heroku oder Vercel-, mit der Sie Full-Stack-Apps, APIs, Datenbanken, Hintergrundarbeiter und mehr mit minimalem DevOps-Overhead bereitstellen können. Mehr auf den Punkt, dass es kostenlos ist, loszulegen und mehr als genug für unsere Bedürfnisse ist. Gehen Sie additionally zu ihren Webseite und melden Sie sich an.

Bevor Sie mit Render bereitgestellt werden, müssen Sie Ihren Code an ein GitHub (oder ein GitLab/Bitbucket) -Repository verpflichten und senden. Danach entscheiden Sie sich auf der Render -Web site, einen neuen Webserver zu erstellen.

Beim ersten Mal fordert Render einen Zugriff auf Ihr Konto mit Github (oder Bitbucket/GitLab) an.

Danach müssen Sie die Befehle bereitstellen, um Ihre Bereitstellung zu erstellen und Ihren Server zu starten. Zum Beispiel ….

Zurück auf der Einstellungen Bildschirm klicken Sie auf die Handbuch Einsetzen -> Das neueste Commit einsetzen Menüelement und ein Protokoll des Construct- und Bereitstellungsvorgangs werden angezeigt. Nach wenigen Minuten sollten Sie die folgenden Nachrichten sehen, die angeben, dass Ihre Bereitstellung erfolgreich conflict.

...
...
==> Construct profitable 🎉
==> Deploying...
==> Working 'uv run mcp_server.py'
...
...
...
==> Obtainable at your major URL https://remote-mcp-syp1.onrender.com==> Obtainable at your major URL https://remote-mcp-syp1.onrender.com
...
Detected service operating on port 10000
...
...

Die lebenswichtige Adresse, die Sie benötigen, ist die mit der primären URL gekennzeichnete Adresse. In unserem Fall ist dies https://remote-mcp-syp1.onrender.com

Testen Sie unseren Distant -MCP -Server

Wir können dies auf die gleiche Weise tun, wie wir das lokale Laufen getestet haben, dh mit Curl. Überprüfen Sie zunächst die maximale Temperatur, diesmal Chicago. Beachten Sie die Änderung der URL zu unserer neuen Fernbedienung.

$ curl --ssl-no-revoke -sN -H "Content material-Kind: software/json" -H "Settle for: software/json, textual content/event-stream" -d '{"jsonrpc":"2.0","id":1,"methodology":"instruments/name","params":{"identify":"get_historical_weekly_high","arguments":{"city_name":"Chicago"}}}' https://remote-mcp-syp1.onrender.com/temp/mcp/|sed -n '/^knowledge:/{s/^knowledge: //;p}'

Und unsere Ausgabe?

{"jsonrpc":"2.0","id":1,"end result":{"content material":({"sort":"textual content","textual content":"95.4"}),"isError":false}}

Die scharfen Augen unter Ihnen haben möglicherweise bemerkt, dass wir eine zusätzliche Flagge aufgenommen haben (-SSL-no-Revoke) im obigen Curl -Befehl im Vergleich zu dem, den wir lokal verwendet haben. Dies ist einfach auf eine Eigenart in der Artwork und Weise zurückzuführen, wie Curl unter Home windows funktioniert. Wenn Sie WSL2 für Home windows oder Linux verwenden, benötigen Sie dieses zusätzliche Flag nicht.

Als nächstes testen wir unseren abgelegenen Nobelpreisprüfer. Diesmal für Chemie im Jahr 2024.

$  $ curl --ssl-no-revoke -sN 
-H 'Content material-Kind: software/json' 
-H 'Settle for: software/json, textual content/event-stream' 
-d '{"jsonrpc":"2.0","id":1,"methodology":"instruments/name","params":{"identify":"nobel_checker","arguments":{"yr":2024,"topic":"Chemistry"}}}' 
'https://remote-mcp-syp1.onrender.com/prize/mcp/' | sed -n '/^knowledge:/{s/^knowledge: //;p}'

Und die Ausgabe?

{"jsonrpc":"2.0","id":1,"end result":{"content material":({"sort":"textual content","textual content":"David Baker"},{"sort":"textual content","textual content":"Demis Hassabis"},{"sort":"textual content","textual content":"John Jumper"}),"isError":false}}

Wenn Sie versuchen möchten, über Code auf den MCP -Server zuzugreifen, anstatt CURL zu verwenden, finden Sie hier ein Beispiel für Python nobel_checker Werkzeug.

import requests
import json
import ssl
from urllib3.exceptions import InsecureRequestWarning
from urllib3 import disable_warnings

# Disable SSL warnings (equal to --ssl-no-revoke)
disable_warnings(InsecureRequestWarning)

def call_mcp_server(url, methodology, tool_name, arguments, request_id=1):
    """
    Name a distant MCP server
    
    Args:
        url (str): The MCP server endpoint URL
        methodology (str): The JSON-RPC methodology (e.g., "instruments/name")
        tool_name (str): Title of the instrument to name
        arguments (dict): Arguments to move to the instrument
        request_id (int): JSON-RPC request ID
    
    Returns:
        dict: Response from the MCP server
    """
    
    # Put together headers
    headers = {
        "Content material-Kind": "software/json",
        "Settle for": "software/json, textual content/event-stream"
    }
    
    # Put together JSON-RPC payload
    payload = {
        "jsonrpc": "2.0",
        "id": request_id,
        "methodology": methodology,
        "params": {
            "identify": tool_name,
            "arguments": arguments
        }
    }
    
    strive:
        # Make the request with SSL verification disabled
        response = requests.submit(
            url,
            headers=headers,
            json=payload,
            confirm=False,  # Equal to --ssl-no-revoke
            stream=True   # Help for streaming responses
        )
        
        # Test if the request was profitable
        response.raise_for_status()
        
        # Attempt to parse as JSON first
        strive:
            return response.json()
        besides json.JSONDecodeError:
            # If not JSON, return the textual content content material
            return {"textual content": response.textual content}
            
    besides requests.exceptions.RequestException as e:
        return {"error": f"Request failed: {str(e)}"}

# Instance utilization
if __name__ == "__main__":
    
    end result = call_mcp_server(
        url="https://remote-mcp-syp1.onrender.com/prize/mcp/",
        methodology="instruments/name",
        tool_name="prize_checker",
        arguments={"yr": 2024, "topic": "Chemistry"}
    )
    print("MCP Device Name Response:")
    print(json.dumps(end result, indent=2))

Die Ausgabe ist.

MCP Device Name Response:
{
  "textual content": "occasion: messagerndata: {"jsonrpc":"2.0","id":1,"end result":{"content material":({"sort":"textual content","textual content":"David Baker"},{"sort":"textual content","textual content":"Demis Hassabis"},{"sort":"textual content","textual content":"John Jumper"}),"isError":false}}rnrn"
}

Zusammenfassung

In diesem Artikel wird vorgestellt, wie es geht Schreiben, testen und bereitstellen Ihr Distant-, Streamable HTTP -Modell -Kontext -Protokoll -Server (MCP) in der Cloud, sodass jeder MCP -Shopper auf Funktionen (Instruments) distant zugreifen kann.

Ich habe Ihnen gezeigt, wie man einige nützliche eigenständige Funktionen codiert-ein Nobelpreisprüfer und ein Instrument der Stadttemperatur. Nach dem Testen dieser lokal mit der Locken Befehl Um sicherzustellen, dass sie wie erwartet gearbeitet haben, haben wir sie in MCP -Instruments umgewandelt und einen MCP -Server codiert. Nachdem wir den MCP -Server vor Ort bereitgestellt und erfolgreich getestet haben, befassten wir uns mit der Bereitstellung unseres Servers in der Cloud.

Zu diesem Zweck habe ich gezeigt, wie man Render, eine Cloud -Internet hosting -Plattform, verwendet und Sie durch die Schritte zur Anmeldung und Bereitstellung (kostenlos) unserer MCP -Server -App führte. Wir haben dann Curl verwendet, um den Distant -Server zu testen und zu bestätigen, dass er wie erwartet funktioniert.

Schließlich habe ich auch einen Python -Code bereitgestellt, mit dem Sie den MCP -Server testen können.

Fühlen Sie sich frei, meinen MCP -Server auf Render selbst zu testen. Beachten Sie, dass der Server nach einer Inaktivitätszeit, da es sich um die freie Stufe befindet, nach einer Inaktivitätsdauer senkt, was zu einer Verzögerung von 30 bis 60 Sekunden beim Abrufen von Ergebnissen führen kann.