mcp-registry

Eine kleine, durchgängige Schritt-für-Schritt-Anleitung zur MLflow MCP Server Registry: Erstellen Sie MCP-Server mit FastMCP, rufen Sie sie mit einem FastMCP-Client auf und registrieren Sie sie dann in MLflow, damit sie auffindbar sind – mit Versionen, Zugriffsendpunkten und automatisch ermittelten Tools.

Das Repository besteht aus drei Komponenten:

Voraussetzungen

• Python ≥ 3.13

• Ein lokal laufender MLflow-Tracking-Server (v3.15+) – die Registry-APIs sind serverseitig

• PostgreSQL, falls Sie den PostgreSQL-Server ausführen möchten

• uv (das Repository enthält eine uv.lock)

Abhängigkeiten (pyproject.toml): fastmcp>=3.4.7, mlflow>=3.15.1, psycopg2 + psycopg2-binary, python-dotenv.

uv sync

Related MCP server: postgres-mcp-readonly

Konfiguration

Der PostgreSQL-Server liest seine Verbindungseinstellungen aus einer .env-Datei im Repository-Stammverzeichnis (geladen über python-dotenv). .env ist in der gitignore enthalten – erstellen Sie Ihre eigene:

PGHOST=localhost
PGPORT=5432
PGUSER=root
PGPASSWORD=root
PGSSLMODE=prefer
PGADMINDB=postgres

src/simple_server.py benötigt keine Konfiguration.

1. Einen MLflow-Tracking-Server starten

mlflow_mcp_registry_util.py zeigt auf http://127.0.0.1:5000. Das Repository enthält bereits eine mlflow.db (gitignored) aus einem SQLite-gestützten Durchlauf:

uv run mlflow server --backend-store-uri sqlite:///mlflow.db --host 127.0.0.1 --port 5000

Wenn Ihr Server woanders läuft, bearbeiten Sie den mlflow.set_tracking_uri(...)-Aufruf am Anfang von mlflow_mcp_registry_util.py.

2. Einen MCP-Server ausführen

Beide Server binden Port 8000 über streamable HTTP (http://localhost:8000/mcp), führen Sie also einen nach dem anderen aus – oder ändern Sie den Port im mcp.run(...)-Aufruf.

Einfacher Begrüßungsserver – zwei Tools, Greeting und Sendoff:

uv run python src/simple_server.py

PostgreSQL-Explorer – schreibgeschützte Einsicht in einen laufenden PostgreSQL-Server:

uv run python src/postgresql_mcp.py

Oder über die FastMCP-CLI:

uv run fastmcp run src/postgresql_mcp.py --transport http --port 8000

PostgreSQL-Tools

Jedes Tool durchläuft _query(), das eine neue Verbindung zur benannten Datenbank öffnet, eine einzelne parametrisierte SELECT-Abfrage über einen RealDictCursor ausführt und die Verbindung schließt. Es wird nichts geschrieben.

3. Einen Server von einem Client aus aufrufen

Mit einem auf Port 8000 laufenden Server:

uv run python clients/postgres_server_client.py   # calls ListDatabases, prints each database name
uv run python clients/simple_server_client.py     # calls the greeting tool with "Ford"

clients/postgres_server_client.py entpackt das FastMCP-Ergebnis: Jedes Element in result.content trägt ein JSON-text-Payload, das geparst und aus dem database gelesen wird.

Hinweis: clients/simple_server_client.py ruft client.call_tool("greet", ...) auf, aber das Tool in src/simple_server.py ist unter dem Namen Greeting registriert (greet ist nur der Python-Funktionsname). Verwenden Sie für den Aufruf "Greeting", um die Auflösung zu gewährleisten.

4. Server bei MLflow registrieren

mlflow_mcp_registry_util.py enthält vier Koroutinen, die jeweils eine Registry-API demonstrieren:

register_postgresql_mcp_server()

Registriert einen entfernten Server – einen, der bereits läuft und über HTTP erreichbar ist:

mlflow.genai.register_mcp_server(
    server_json={
        "name": "io.github.pavanjava/postgresql-server",
        "version": "0.1.0",
        "description": "PostgreSQL FastMCP server exposing DB tools",
        "remotes": [{"url": "http://localhost:8000/mcp", "type": "streamable-http"}],
    },
    status="active",
    source="local dev server via fastmcp",
    create_access_endpoints_from_remotes=True,
)

create_access_endpoints_from_remotes=True wandelt jeden Eintrag in remotes in einen MLflow-Zugriffsendpunkt um, sodass Verbraucher eine Verbindungs-URL aus der Registry auflösen können, anstatt sie fest zu codieren.

register_qdrant_mcp_server()

Registriert stattdessen einen paketierten Server – kein laufender Prozess erforderlich. Der Eintrag beschreibt, wie er gestartet wird (uvx mcp-server-qdrant über stdio) und deklariert seine Umgebungsvariablen, einschließlich derer, die erforderlich sind und welche geheim sind (QDRANT_API_KEY).

discover_tools()

Ruft refresh_mcp_server_version_tools(...) auf. MLflow verbindet sich mit der registrierten Serverversion, ermittelt seine Tools und speichert sie in der Version – danach listet server_version.tools die ermittelten Toolnamen auf. Dazu muss der Server tatsächlich erreichbar sein.

list_endpoints()

Ruft search_mcp_access_endpoints(server_name=...) auf und gibt für jeden Endpunkt dessen URL, Transporttyp und die aufgelöste Serverversion aus.

Ausführen

Der __main__-Block führt jeweils eine Koroutine aus; die restlichen sind auskommentiert. Kommentieren Sie die gwünschte aus:

if __name__ == "__main__":
    # asyncio.run(register_postgresql_mcp_server())
    asyncio.run(register_qdrant_mcp_server())
    # asyncio.run(discover_tools())
    # asyncio.run(list_endpoints())

uv run python mlflow_mcp_registry_util.py

Registrierte Server werden dann im Abschnitt MCP Servers der MLflow-Oberfläche unter http://127.0.0.1:5000 angezeigt.

Vorgeschlagener End-to-End-Pfad

1. Starten Sie MLflow auf Port 5000.

2. Starten Sie den PostgreSQL-MCP-Server auf Port 8000.

3. Überprüfen Sie die Antwort: uv run python clients/postgres_server_client.py.

4. Registrieren Sie ihn: Kommentieren Sie register_postgresql_mcp_server() aus und führen Sie das Hilfsprogramm aus.

5. Ermitteln Sie seine Tools: Wechseln Sie zu discover_tools() und führen Sie es erneut aus – die sechs obigen Tools sollten ausgegeben werden.

6. Überprüfen Sie seinen Zugriffsendpunkt: Wechseln Sie zu list_endpoints().

7. Durchsuchen Sie das Ergebnis in der MLflow-Oberfläche.

Repository-Struktur

.
├── src/
│   ├── simple_server.py        # FastMCP "My MCP Server" — Greeting + Sendoff tools
│   └── postgresql_mcp.py       # FastMCP "PostgreSQL Explorer" — 6 read-only introspection tools
├── clients/
│   ├── simple_server_client.py     # calls a tool on the greeting server
│   └── postgres_server_client.py   # calls ListDatabases and prints database names
├── mlflow_mcp_registry_util.py # MLflow MCP registry: register / refresh tools / list endpoints
├── pyproject.toml
└── uv.lock

mlflow.db, .env, .venv und .idea sind in der gitignore enthalten.