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"
  $$

Copy

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

CUSTOM: Tool für UDFs und gespeicherte Prozeduren

Die folgenden Beispiele zeigen, wie Sie verschiedene Tooltypen konfigurieren können:
Für das Analyst-Tool übergibt Ihr Client Meldungen in der Anforderung. Sie müssen den Namen des Tools , das in der Anforderung aufgerufen werden soll, als 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"
      }
    }
  }
Copy
Das folgende Beispiel zeigt die Antwort:
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "string"
      }
    ]
  }
}
Copy
Bei Suchtool-Anfragen kann Ihr Client die Abfrage und die folgenden optionalen Argumente übergeben:

columns

filter

limit

Die Suchergebnisse und die Anfrage-ID werden in der Ausgabe aufgeführt. Sie müssen den Namen des Tools , das in der Anforderung aufgerufen werden soll, als 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,
        "filter": json,
        "limit": int
      }
    }
  }
Copy
Das folgende Beispiel zeigt die Antwort:
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "results": {}
  }
}
Copy
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."
Copy
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..."
Copy
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

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))
$$;

Copy

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))
$$;

Copy

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: "CUSTOM"
          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: "CUSTOM"
          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: "CUSTOM"
          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: "CUSTOM"
          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: "CUSTOM"
          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: "CUSTOM"
          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"
  $$;

Copy

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;

Copy

Das folgende Beispiel zeigt 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>;

Copy

Das folgende Beispiel zeigt 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>;

Copy

Zugriffssteuerung¶

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

Berechtigung	Objekt	Beschreibung
OWNERSHIP	MCP-Objekt	Erforderlich, um die Objektkonfiguration zu aktualisieren
MODIFY	MCP-Objekt	Ermöglicht das Aktualisieren, Löschen, Beschreiben, Anzeigen und Verwenden von (`tools/list` und `tools/call`) für die Objektkonfiguration
USAGE	MCP-Objekt	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>'

Copy

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>');
```
Copy

Bemerkung

Wenn Sie sich von Ihrem MCP-Client bei Snowflake anmelden, sehen Sie möglicherweise eine Invalid consent request-Fehlermeldung beim ersten Versuch. Um dies zu beheben, suchen Sie den Parameter für die Bereichsabfrage mit dem folgenden Format in der Autorisierungs- URL.

&scope=session%3Arole%3Aall

Ändern Sie den Geltungsbereich von session%3Arole%3Aall zu session%3Arole%3Arole name you want to authenticate und übermitteln Sie den erneut die URL.

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

Falls Sie einen kundenspezifischen MCP-Client erstellen, werden in den folgenden Abschnitten die Snowflake-Endpunkte beschrieben, mit denen Ihr Client interagiert.

Bemerkung

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

Initialisieren des MCP-Servers¶

Initialisieren Sie den Server nach der Authentifizierung, indem Sie GET- und POST-Aufrufe an den folgenden API-Endpunkt ausführen:

POST /api/v2/databases/{database}/schemas/{schema}/mcp-servers/{name}
    {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "initialize",
        "params": { "protocolVersion": "2025-06-18" }
    }

Copy

Das folgende Beispiel zeigt die Antwort:

{
    "jsonrpc": "2.0", // passthrough from req
    "id": 1, // passthrough from req
    "result": {
        "proto_version": "2025-06-18",
        "capabilities": {
            "tools": {
                "listChanged": false
            }
        },
        "server_info": {
            "name": "<snowflake-mcp-name>",
            "title": "Snowflake Server: <snowflake-mcp-name>",
            "version": "1.0.0"
        }
    }
}

Copy

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 der Spalte tools/list-Anforderung gezeigt:

POST /api/v2/databases/{database}/schemas/{schema}/mcp-servers/{name}
    {
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/list",
        "params": {}
    }

Copy

Das folgende Beispiel zeigt die Antwort:

{
    "jsonrpc": "2.0", // passthrough from req
    "id": 1, // passthrough from req
    "result": {
        "tools": [ // search
            {
                "name":"product-search",
                "description":"Test search tool",
                "inputSchema": {
                    "type": "object",
                    "description": "A search query and additional parameters for search.",
                    "properties": {
                        "query": {
                            "description": "Unstructured text query.  Exactly one of 'query' or 'multi_index_query' must be specified.",
                            "type": "string"
                        },
                        "columns": {
                            "description": "List of columns to return.",
                            "type": "array",
                            "items": {
                                "type": "string"
                            }
                        },
                        "filter": {
                            "description": "Filter query.",
                            "type": "object"
                        },
                        "limit": {
                            "description": "Max number of results to return.",
                            "type": "integer",
                            "default": 10
                        }
                    }
                },
                "outputSchema": {
                    "type": "object",
                    "description": "Search results.",
                    "properties": {
                        "results": {
                            "description": "List of result rows.",
                            "type": "array",
                            "items": {
                                "type": "object",
                                "additionalProperties": true,
                                "description": "Map of column names to values (as bytes)."
                            }
                        },
                    "request_id": {
                        "description": "ID of the request.",
                        "type": "string"
                    }
                },
                "required": ["results", "request_id"]
            }
          },
          { // analyst
              "name":"revenue-semantic-view",
              "description":"Test tool",
              "inputSchema": {
                  "type": "object",
                  "description": "A message and additional parameters for Cortex Analyst.",
                  "properties": {
                      "message": {
                          "description": "The user’s question.",
                          "type": "string"
                      }
                  }
              }
          }
        ]
    }
}

Copy

Um ein Tool aufzurufen, geben Sie einen POST-Aufruf aus, wie in der Spalte tools/call-Anforderung gezeigt.

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.