Snowflake-verwalteter MCP-Server¶

Übersicht¶

Bemerkung

Snowflake unterstützt das Modellkontextprotokoll in Revision 2025-06-18.

Modell-Kontextprotokoll (MCP) ist ein Open-Source-Standard, der AI-Agenten erlaubt, sicher mit Geschäftsanwendungen und externen Datensystemen wie Datenbanken und Inhaltsrepositorys zu interagieren. Mit MCP können Unternehmen Integrationsherausforderungen reduzieren und schnell Ergebnisse aus Modellen liefern. Seit seiner Einführung ist MCP zu einer grundlegenden Unterstützung für agentenbasierte Anwendungen geworden und bietet einen konsistenten und sicheren Mechanismus für den Aufruf von Tools und den Abruf von Daten.

Der von Snowflake verwaltete MCP-Server lässt AI-Agenten rufen Daten sicher aus Snowflake-Konten ab, ohne dass eine separate Infrastruktur bereitgestellt werden muss. Sie können den MCP-Server so konfigurieren, dass Cortex Analyst, Cortex Search und Cortex Agents zusammen mit kundenspezifischen Tools und SQL-Ausführungen als Tools auf der standardbasierten Schnittstelle bereitgestellt werden. MCP-Clients erkennen und rufen diese Tools auf und rufen die für die Anwendung erforderlichen Daten ab. Mit verwalteten MCP-Servern auf Snowflake können Sie skalierbare, unternehmensweite Anwendungen erstellen und dabei die Zugriffs- und Datenschutzkontrollen beibehalten. Der MCP-Server auf Snowflake bietet:

Standardisierte Integration: Einheitliche Schnittstelle für die Erkennung und den Aufruf von Tools, in Übereinstimmung mit den sich schnell entwickelnden Standards.
Umfassende Authentifizierung: In Snowflake integrierter OAuth-Service, der OAuth-basierte Authentifizierung für MCP-Integrationen ermöglichen soll.
Robuste Governance: Rollenbasierte Zugriffssteuerung (RBAC) für MCP-Server und -Tools zur Verwaltung der Erkennung und des Aufrufs von Tools.

Weitere Informationen zum MCP-Lebenszyklus finden Sie unter Lebenszyklus. Ein Beispiel für eine MCP-Implementierung finden Sie unter Erste Schritte mit dem verwalteten Snowflake MCP-Server Quickstart.

Sicherheitsempfehlungen für den MCP-Server¶

Wichtig

Wenn Sie Hostnamen für MCP-Serververbindungen konfigurieren, verwenden Sie Bindestriche (-) anstelle von Unterstrichen (_). MCP-Server haben Verbindungsprobleme bei Hostnamen, die Unterstriche enthalten.

Die Verwendung mehrerer MCP-Server ohne Verifizierung der Tools und Beschreibungen könnte zu Sicherheitslücken wie Tool Poisoning oder Tool Shadowing führen. Snowflake empfiehlt, MCP-Server von Dritten vor deren Verwendung zu überprüfen. Dazu gehören alle MCP-Server von einem anderen Snowflake-Benutzenden oder -Konto aus. Überprüfen Sie alle Tools, die von Drittanbietern von MCP-Servern angeboten werden.

Wir empfehlen die Verwendung von OAuth als Authentifizierungsmethode. Die Verwendung von hartcodierten Token kann zu Token-Verlusten führen.

Bei der Nutzung eines programmgesteuerten Zugriffstokens (PAT) sollten Sie es so einrichten, dass es die Rolle mit den geringsten Berechtigungen für das Arbeiten mit MCP verwendet. Dadurch wird verhindert, dass ein Geheimnis durch Zugriff auf eine Rolle mit hohen Berechtigungen preisgegeben wird.

Konfigurieren Sie die richtigen Berechtigungen für den MCP-Server und die Tools nach dem Prinzip der niedrigsten Berechtigungen. Der Zugriff auf den MCP-Server gewährt keinen Zugriff auf die Tools. Für jedes Tool muss eine Berechtigung erteilt werden.

Erstellen eines MCP-Serverobjekts¶

Erstellen Sie ein Objekt, indem Sie die Tools und andere Metadaten angeben. MCP-Clients, die sich nach der erforderlichen Authentifizierung mit dem Server verbinden, können diese Tools erkennen und aufrufen.

Navigieren Sie zu der gewünschten Datenbank und dem gewünschten Schema, um den MCP-Server darin zu erstellen.

So erstellen Sie den MCP-Server:

CREATE [ OR REPLACE ] MCP SERVER [ IF NOT EXISTS ] <server_name>
  FROM SPECIFICATION $$
    tools:
      - name: "product-search"
        type: "CORTEX_SEARCH_SERVICE_QUERY"
        identifier: "database1.schema1.Cortex_Search_Service1"
        description: "cortex search service for all products"
        title: "Product Search"

      - name: "revenue-semantic-view"
        type: "CORTEX_ANALYST_MESSAGE"
        identifier: "database1.schema1.Semantic_View_1"
        description: "Semantic view for all revenue tables"
        title: "Semantic view for revenue"
  $$

Snowflake unterstützt derzeit die folgenden Tooltypen:

CORTEX_SEARCH_SERVICE_QUERY: Cortex Search Service-Tool

CORTEX_ANALYST_MESSAGE: Cortex Analyst-Tool

SYSTEM_EXECUTE_SQL: SQL-Ausführung

CORTEX_AGENT_RUN: Cortex Agent-Tool

GENERIC: Tool für UDFs und gespeicherte Prozeduren

Die folgenden Beispiele zeigen, wie Sie verschiedene Tooltypen konfigurieren können:
Mit dem Analysten-Tool kann Ihr Client SQL aus Text in natürlicher Sprache generieren. Verwenden Sie den folgenden Code, um die Konfiguration des Tools anzugeben.

Bemerkung

Der von Snowflake verwaltete MCP-Server unterstützt nur die Verwendung von semantischen Ansichten mit Cortex Analyst. Es werden keine semantischen Modelle unterstützt.
tools:
  - name: "revenue-semantic-view"
    type: "CORTEX_ANALYST_MESSAGE"
    identifier: "database1.schema1.Semantic_View_1"
    description: "Semantic view for all revenue tables"
    title: "Semantic view for revenue"
Mit den Suchtool-Anfragen kann Ihr Client eine unstrukturierte Suche in seinen Daten durchführen.
tools:
  - name: "product-search"
    type: "CORTEX_SEARCH_SERVICE_QUERY"
    identifier: "database1.schema1.Cortex_Search_Service1"
    description: "cortex search service for all products"
    title: "Product Search"
Für das SQL-Ausführungstool kann Ihr Client SQL-Abfragen in Snowflake ausführen. Verwenden Sie den folgenden Code, um die Konfiguration des Tools anzugeben.
tools:
  - title: "SQL Execution Tool"
    name: "sql_exec_tool"
    type: "SYSTEM_EXECUTE_SQL"
    description: "A tool to execute SQL queries against the connected Snowflake database."
Beim Agententool übergibt Ihr Client eine Nachricht an den Agenten. Der Agent verarbeitet die Anfrage und gibt eine Antwort zurück. Verwenden Sie den folgenden Code, um die Konfiguration des Tools anzugeben.
tools:
  - title: "Agent V2"
    name: "agent_1"
    type: "CORTEX_AGENT_RUN"
    identifier: "db.schema.agent"
    description: "agent that gives the ability to..."
Für Ihre kundenspezifischen Tools müssen Sie die benutzerdefinierte Funktion (User-Defined Function, UDF) oder eine Signatur für gespeicherte Prozeduren in der Konfiguration des Tools bereitstellen. Mit dem kundenspezifischen Tool können Sie UDFs und gespeicherte Prozeduren als Tools über den MCP-Server aufrufen.

Sie müssen in der Toolkonfiguration folgende Angaben machen:

type: function für UDF, procedure für gespeicherte Prozeduren

Warehouse. Wenn Sie kein Warehouse angeben, wird das Standard-Warehouse verwendet.

Input schema: entspricht der Funktionssignatur

Verwenden Sie die folgenden Beispiele, um kundenspezifische Tools mit UDFs und gespeicherten Prozeduren zu erstellen und zu konfigurieren:

Die folgenden Beispiele zeigen die Erstellung von UDFs, die als kundenspezifische Tools verwendet werden können:

-- create a simple udf
CREATE OR REPLACE FUNCTION MULTIPLY_BY_TEN(x FLOAT)
RETURNS FLOAT
LANGUAGE PYTHON
RUNTIME_VERSION = '3.8'
HANDLER = 'multiply_by_ten'
AS
$$
def multiply_by_ten(x: float) -> float:
  return x * 10
$$;

SHOW FUNCTIONS LIKE 'MULTIPLY_BY_TEN';

-- test return json/variant
CREATE OR REPLACE FUNCTION CALCULATE_PRODUCT_AND_SUM(x FLOAT, y FLOAT)
RETURNS VARIANT
LANGUAGE PYTHON
RUNTIME_VERSION = '3.8'
HANDLER = 'calculate_values'
AS
$$
import json

def calculate_values(x: float, y: float) -> dict:
  """
  Calculates the product and sum of two numbers and returns them in a dictionary.
  The dictionary is converted to a VARIANT (JSON) in the SQL return.
  """
  product = x * y
  sum_val = x + y

  return {
      "product": product,
      "sum": sum_val
  }
$$;

-- test return list/array
CREATE OR REPLACE FUNCTION GET_NUMBERS_IN_RANGE(x FLOAT, y FLOAT)
RETURNS ARRAY -- Use ARRAY to explicitly state a list is being returned
LANGUAGE PYTHON
RUNTIME_VERSION = '3.8'
HANDLER = 'get_numbers'
AS
$$
def get_numbers(x: float, y: float) -> list:
  """
  Returns a list of integers between x (exclusive) and y (inclusive).
  Assumes x < y.
  """
  # Ensure x and y are treated as integers for range generation
  start = int(x) + 1
  end = int(y) + 1 # range() is exclusive on the stop value

  # Use a list comprehension to generate the numbers
  # The Python list will be converted to a Snowflake ARRAY.
  return list(range(start, end))
$$;

Die folgenden Beispiele zeigen das Erstellen von gespeicherten Prozeduren, die als kundenspezifische Tools verwendet werden können:

-- create a simple stored procedure
CREATE OR REPLACE PROCEDURE MULTIPLY_BY_TEN_SP(x FLOAT)
RETURNS FLOAT
LANGUAGE PYTHON
RUNTIME_VERSION = '3.8'
PACKAGES = ('snowflake-snowpark-python')
HANDLER = 'multiply_by_ten'
AS
$$
# The handler logic is identical to the UDF for a scalar return
def multiply_by_ten(x: float) -> float:
      return x * 10
$$;

-- test return json/variant
CREATE OR REPLACE PROCEDURE CALCULATE_VALUES_SP(x FLOAT, y FLOAT)
RETURNS VARIANT
LANGUAGE PYTHON
RUNTIME_VERSION = '3.8'
PACKAGES = ('snowflake-snowpark-python')
HANDLER = 'calculate_values'
AS
$$
# The handler logic is identical to the UDF for a VARIANT return
def calculate_values(x: float, y: float) -> dict:
      """
      Calculates the product and sum of two numbers and returns them in a dictionary.
      The dictionary is converted to a VARIANT (JSON) in the SQL return.
      """
      product = x * y
      sum_val = x + y

      return {
          "product": product,
          "sum": sum_val
      }
$$;

-- test return list/array
CREATE OR REPLACE PROCEDURE GET_NUMBERS_SP(x FLOAT, y FLOAT)
RETURNS ARRAY
LANGUAGE PYTHON
RUNTIME_VERSION = '3.8'
PACKAGES = ('snowflake-snowpark-python')
HANDLER = 'get_numbers'
AS
$$
def get_numbers(x: float, y: float) -> list:
      """
      Returns a list of integers between x (exclusive) and y (inclusive).
      The Python list will be converted to a Snowflake ARRAY.
      """
      # Ensure x and y are treated as integers for range generation
      start = int(x) + 1
      end = int(y) + 1 # range() is exclusive on the stop value

      # Use a list comprehension to generate the numbers
      return list(range(start, end))
$$;

Die folgenden Beispiele zeigen die Konfiguration kundenspezifischer Tools für UDFs und gespeicherte Prozeduren:

CREATE MCP SERVER my_mcp_server
  FROM SPECIFICATION $$
    tools:
      - title: "Custom Tool 1"
        identifier: "EXAMPLE_DATABASE.AGENTS.MULTIPLY_BY_TEN"
        name: "multiply_by_ten"
        type: "GENERIC"
        description: "Multiplied input value by ten and returns the result."
        config:
          type: "function"
          warehouse: "COMPUTE_SERVICE_WAREHOUSE"
          input_schema:
            type: "object"
            properties:
              x:
                description: "A number to be multiplied by ten"
                type: "number"
      - title: "Custom Tool 2"
        identifier: "EXAMPLE_DATABASE.AGENTS.CALCULATE_PRODUCT_AND_SUM"
        name: "calculate_product_and_sum"
        type: "GENERIC"
        description: "Calculates the product and sum of two numbers and returns them in a JSON object."
        config:
          type: "function"
          warehouse: "COMPUTE_SERVICE_WAREHOUSE"
          input_schema:
            type: "object"
            properties:
              x:
                description: "First number"
                type: "number"
              y:
                description: "Second number"
                type: "number"
      - title: "Custom Tool 3"
        identifier: "EXAMPLE_DATABASE.AGENTS.GET_NUMBERS_IN_RANGE"
        name: "get_numbers_in_range"
        type: "GENERIC"
        description: "Returns a list of integers between two numbers."
        config:
          type: "function"
          warehouse: "COMPUTE_SERVICE_WAREHOUSE"
          input_schema:
            type: "object"
            properties:
              x:
                description: "Start number (exclusive)"
                type: "number"
              y:
                description: "End number (inclusive)"
                type: "number"
      - title: "Custom Tool 4"
        identifier: "EXAMPLE_DATABASE.AGENTS.MULTIPLY_BY_TEN_SP"
        name: "multiply_by_ten_sp"
        type: "GENERIC"
        description: "Multiplied input value by ten and returns the result."
        config:
          type: "procedure"
          warehouse: "COMPUTE_SERVICE_WAREHOUSE"
          input_schema:
            type: "object"
            properties:
              x:
                description: "A number to be multiplied by ten"
                type: "number"
      - title: "Custom Tool 5"
        identifier: "EXAMPLE_DATABASE.AGENTS.CALCULATE_PRODUCT_AND_SUM_SP"
        name: "calculate_product_and_sum_sp"
        type: "GENERIC"
        description: "Calculates the product and sum of two numbers and returns them in a JSON object."
        config:
          type: "procedure"
          warehouse: "COMPUTE_SERVICE_WAREHOUSE"
          input_schema:
            type: "object"
            properties:
              x:
                description: "First number"
                type: "number"
              y:
                description: "Second number"
                type: "number"
      - title: "Custom Tool 6"
        identifier: "EXAMPLE_DATABASE.AGENTS.GET_NUMBERS_IN_RANGE_SP"
        name: "get_numbers_in_range_sp"
        type: "GENERIC"
        description: "Returns a list of integers between two numbers."
        config:
          type: "procedure"
          warehouse: "COMPUTE_SERVICE_WAREHOUSE"
          input_schema:
            type: "object"
            properties:
              x:
                description: "Start number (exclusive)"
                type: "number"
              y:
                description: "End number (inclusive)"
                type: "number"
  $$;

Zum Anzeigen von MCP-Servern verwenden Sie die folgenden Befehle:

SHOW MCP SERVERS IN DATABASE <database_name>;
SHOW MCP SERVERS IN SCHEMA <schema_name>;
SHOW MCP SERVERS IN ACCOUNT;

Im Folgenden sehen Sie die Ausgabe des Befehls:

|               created_on               |       name        | database_name | schema_name |    owner     |           comment            |
------------------------------------------+-------------------+---------------+-------------+--------------+------------------------------
| Fri, 23 Jun 1967 07:00:00.123000 +0000 | TEST_MCP_SERVER   | TEST_DATABASE | TEST_SCHEMA | ACCOUNTADMIN | [NULL]                       |
| Fri, 23 Jun 1967 07:00:00.123000 +0000 | TEST_MCP_SERVER_2 | TEST_DATABASE | TEST_SCHEMA | ACCOUNTADMIN | Test MCP server with comment |

Um einen MCP-Server zu beschreiben, verwenden Sie den folgenden Befehl:

DESCRIBE MCP SERVER <server_name>;

Im Folgenden sehen Sie die Ausgabe des Befehls:

|      name       | database_name | schema_name |    owner     | comment |     server_spec        |               created_on               |
------------------------------------------------------------------------------------------------------+-------------------------------------
| TEST_MCP_SERVER | TEST_DATABASE | TEST_SCHEMA | ACCOUNTADMIN | [NULL]  | {"version":1,"tools":[{"name":"product-search","identifier":"db.schema.search_service","type":"CORTEX_SEARCH_SERVICE_QUERY"}]} | Fri, 23 Jun 1967 07:00:00.123000 +0000 |

Um einen MCP-Server zu entfernen, verwenden Sie den folgenden Befehl:
```
DROP MCP SERVER <server_name>;
```

Zugriffssteuerung¶

Sie können die folgenden Berechtigungen verwenden, um den Zugriff auf den MCP-Server und die zugrunde liegenden Tools zu verwalten.


Berechtigung	Objekt	Beschreibung
CREATE	MCP-SERVER	Erforderlich, um den MCP-Server zu erstellen
OWNERSHIP	MCP-SERVER	Erforderlich, um die Objektkonfiguration zu aktualisieren
MODIFY	MCP-SERVER	Ermöglicht das Aktualisieren, Löschen, Beschreiben, Anzeigen und Verwenden von (`tools/list` und `tools/call`) für die Objektkonfiguration
USAGE	MCP-SERVER	Erforderlich für die Verbindung mit dem MCP-Server und Erkennungstools
USAGE	Cortex Search Service	Erforderlich, um das Cortex Search-Tool im MCP-Server aufzurufen
SELECT	Semantic View	Erforderlich, um das Cortex Analyst-Tool im MCP-Server aufzurufen
USAGE	Cortex Agent	Erforderlich, um Cortex Analyst als Tool im MCP-Server aufzurufen
USAGE	Benutzerdefinierte Funktion (UDF) oder gespeicherte Prozedur	Erforderlich, um die UDF oder gespeicherte Prozedur als Tool im MCP-Server aufzurufen

Einrichten der OAuth-Authentifizierung¶

Konfigurieren Sie die Authentifizierung auf dem MCP-Client. Der von Snowflake verwaltete MCP-Server unterstützt OAuth 2.0 in Übereinstimmung mit der Empfehlung zur `Autorisierung<https://modelcontextprotocol.io/specification/2025-06-18/basic/authorization>`__ im MCP-Protokoll. Der von Snowflake verwaltete MCP-Server unterstützt keine dynamische Clientregistrierung.

Erstellen Sie zuerst die Sicherheitsintegration. Weitere Informationen zu diesem Befehl finden Sie unter CREATE SECURITY INTEGRATION (Snowflake OAuth).

CREATE [ OR REPLACE ] SECURITY INTEGRATION [IF NOT EXISTS] <integration_name>
  TYPE = OAUTH
  OAUTH_CLIENT = CUSTOM
  ENABLED = TRUE
  OAUTH_CLIENT_TYPE = 'CONFIDENTIAL'
  OAUTH_REDIRECT_URI = '<redirect_URI>'

Rufen Sie dann die Systemfunktion auf, um Ihre Client-ID und die Schlüssel für die Clientkonfiguration abzurufen. Der Integrationsname unterscheidet zwischen Groß- und Kleinschreibung und muss in Großbuchstaben geschrieben werden.
```
SELECT SYSTEM$SHOW_OAUTH_CLIENT_SECRETS('<integration_name>');
```

Interagieren mit MCP-Server mit einem kundenspezifischen MCP-Client¶

Wenn Sie einen kundenspezifischen MCP-Client erstellen, müssen Sie den URL-Endpunkt mit dem folgenden Format verwenden:

https://<account_URl>/api/v2/databases/{database}/schemas/{schema}/mcp-servers/{name}

Informationen zum Formatieren Ihrer Konto-URL finden Sie unter Kontobezeichner.

Weitere Informationen zur Interaktion mit dem MCP-Server unter Erstellen eines MCP-Clients.

Bemerkung

Der Snowflake MCP-Server unterstützt derzeit nur Tool-Funktionen.

Tools erkennen und aufrufen¶

Die MCP-Clients können Tools mit tools/list- und tools/call-Anforderungen erkennen und aufrufen.

Um Tools zu erkennen, geben Sie einen POST-Aufruf aus, wie in unter tools/list-Anforderung gezeigt:

Für das Analyst-Tool übergibt Ihr Client Meldungen in der Anforderung. Die SQL-Anweisung ist in der Ausgabe aufgeführt. Sie müssen den Namen des Tools, das Sie in der Anfrage aufrufen, im Parameter name übergeben.

POST /api/v2/databases/<database>/schemas/<schema>/mcp-servers/<name>
    {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {
            "name": "test-analyst",
            "arguments": {
                "message": "text"
            }
        }
    }

Das folgende Beispiel zeigt die Antwort:

{
    "jsonrpc": "2.0",
    "id": 1,
    "result": {
        "content": [
            {
                "type": "text",
                "text": "string"
            }
        ]
    }
}

Bei Suchtool-Anfragen kann Ihr Client die Abfrage und die folgenden optionalen Argumente übergeben:

columns
limit

Die Suchergebnisse und die Anfrage-ID werden in der Ausgabe zurückgegeben. Sie müssen den Namen des Tools, das Sie in der Anfrage aufrufen, im Parameter name übergeben.

POST /api/v2/databases/{database}/schemas/{schema}/mcp-servers/{name}
    {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {
            "name": "product-search",
            "arguments": {
                "query": "Hotels in NYC",
                "columns": array of strings,
                "limit": int
            }
        }
  }

Das folgende Beispiel zeigt die Antwort:

{
    "jsonrpc": "2.0",
    "id": 1,
    "result": {
        "results": {}
    }
}

Einschränkungen¶

Der Snowflake-verwaltete MCP-Server unterstützt die folgenden Konstrukte im MCP-Protokoll nicht: Ressourcen, Prompts, Roots, Benachrichtigungen, Versionsverhandlungen, Lebenszyklusphasen und Sampling.

Es werden nur Nicht-Streaming-Antworten unterstützt.