Inicio rápido: Creación de un servidor MCP remoto personalizado mediante Azure Functions

En este inicio rápido, creará un servidor personalizado de Protocolo de contexto de modelo remoto (MCP) a partir de un proyecto de plantilla mediante la CLI para desarrolladores de Azure (azd). El servidor MCP usa la extensión de servidor MCP de Azure Functions para proporcionar herramientas para modelos, agentes y asistentes de INTELIGENCIA ARTIFICIAL. Después de ejecutar el proyecto localmente y comprobar el código mediante GitHub Copilot, se implementa en una nueva aplicación de funciones sin servidor en Azure Functions que sigue los procedimientos recomendados actuales para implementaciones seguras y escalables.

Sugerencia

Functions también le permite implementar un proyecto de código de servidor MCP existente en una aplicación de plan de consumo flexible sin tener que realizar cambios en el proyecto de código. Para más información, consulte Inicio rápido: Hospedaje de servidores MCP existentes en Azure Functions.

Dado que la nueva aplicación se ejecuta en el plan de consumo flexible, que sigue un modelo de facturación de pago por uso , completar este inicio rápido conlleva un pequeño costo de unos pocos centavos de USD o menos en su cuenta de Azure.

Importante

Aunque se admite la creación de servidores MCP personalizados para todos los lenguajes de Functions, este escenario de inicio rápido solo tiene actualmente ejemplos para C#, Python y TypeScript. Para completar este inicio rápido, seleccione uno de estos idiomas admitidos en la parte superior del artículo.

En este artículo se admite la versión 4 del modelo de programación de Node.js para Azure Functions.

En este artículo se admite la versión 2 del modelo de programación de Python para Azure Functions.

Prerrequisitos

SDK de .NET 8.0

Kit para desarrolladores de Java 17
- Si usa otra versión compatible de Java, debe actualizar el archivo pom.xml del proyecto.
- Establezca la JAVA_HOME variable de entorno en la ubicación de instalación de la versión correcta del Kit de desarrollo de Java (JDK).
Apache Maven 3.8.x

Node.js 20

Python 3.11

Visual Studio Code con estas extensiones:
- La extensión de Azure Functions. Esta extensión requiere Azure Functions Core Tools e intenta instalarla cuando no está disponible.
- Extensión de la CLI para desarrolladores de Azure.
Emulador Storage Azurite
CLI de Azure. También puede ejecutar comandos de la CLI de Azure en Azure Cloud Shell.
Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.

Inicialización del proyecto

Use el azd init comando para crear un proyecto de código local de Azure Functions a partir de una plantilla.

En Visual Studio Code, abra una carpeta o un área de trabajo donde quiera crear el proyecto.

En el terminal, ejecute este azd init comando:
```
azd init --template remote-mcp-functions-dotnet -e mcpserver-dotnet
```
Este comando extrae los archivos del proyecto del repositorio de plantillas e inicializa el proyecto en la carpeta actual. La marca -e establece un nombre para el entorno actual. En azd, el entorno mantiene un contexto de implementación único para la aplicación y puede definir más de uno. También se usa en el nombre del grupo de recursos que crea en Azure.

En el terminal local o el símbolo del sistema, ejecute este comando azd init:
```
azd init --template remote-mcp-functions-java -e mcpserver-java 
```
Este comando extrae los archivos del proyecto del repositorio de plantillas e inicializa el proyecto en la carpeta actual. La marca -e establece un nombre para el entorno actual. En azd, el entorno mantiene un contexto de implementación único para la aplicación y puede definir más de uno. También se usa en los nombres de los recursos que crea en Azure.

En el terminal local o el símbolo del sistema, ejecute este comando azd init:
```
azd init --template remote-mcp-functions-typescript -e mcpserver-ts
```
Este comando extrae los archivos del proyecto del repositorio de plantillas e inicializa el proyecto en la carpeta actual. La marca -e establece un nombre para el entorno actual. En azd, el entorno mantiene un contexto de implementación único para la aplicación y puede definir más de uno. También se usa en los nombres de los recursos que crea en Azure.

En el terminal local o el símbolo del sistema, ejecute este comando azd init:
```
azd init --template remote-mcp-functions-python -e mcpserver-python
```
Este comando extrae los archivos del proyecto del repositorio de plantillas e inicializa el proyecto en la carpeta actual. La marca -e establece un nombre para el entorno actual. En azd, el entorno mantiene un contexto de implementación único para la aplicación y puede definir más de uno. También se usa en los nombres de los recursos que crea en Azure.

Inicio del emulador de almacenamiento

Use el emulador de Azurite para simular una conexión de cuenta de Azure Storage al ejecutar el proyecto de código localmente.

Si aún no lo ha hecho, instale Azurite.
Presione F1. En la paleta de comandos, busque y ejecute el comando Azurite: Start para iniciar el emulador de almacenamiento local.

Ejecución local del servidor MCP

Visual Studio Code se integra con Azure Functions Core Tools para permitirle ejecutar este proyecto en el equipo de desarrollo local mediante el emulador de Azurite.

Para iniciar la función localmente, presione F5 o el icono Ejecutar y depurar en la barra de actividad del lado izquierdo. El panel Terminal muestra la salida de Core Tools. La aplicación se inicia en el panel Terminal y puede ver el nombre de las funciones que se ejecutan localmente.
Anote el punto de conexión del servidor MCP local (como http://localhost:7071/runtime/webhooks/mcp), que se usa para configurar GitHub Copilot en Visual Studio Code.

Comprobación del uso de GitHub Copilot

Para comprobar el código, agregue el proyecto en ejecución como servidor MCP para GitHub Copilot en Visual Studio Code:

Presione F1. En la paleta de comandos, busque y ejecute MCP: Agregar servidor.
Elija HTTP (Server-Sent Events) para el tipo de transporte.
Escriba la dirección URL del punto de conexión de MCP que copió en el paso anterior.
Use el id. de servidor generado y seleccione Área de trabajo para guardar la conexión del servidor MCP a la configuración del área de trabajo.
Abra la paleta de comandos y ejecute MCP: Enumerar servidores y compruebe que el servidor que agregó aparece y ejecuta.
En el chat de Copilot, seleccione Modo de agente y ejecute este mensaje:
```
Say Hello
```
Cuando se le pida que ejecute la herramienta, seleccione Permitir en este área de trabajo para que no tenga que seguir concediéndole permiso. El comando se ejecuta y devuelve una respuesta, y la información de ejecución de funciones se escribe en los registros de ejecución.
Ahora, seleccione código en uno de los archivos de su proyecto y ejecute este comando:
```
Save this snippet as snippet1
```
Copilot almacena el fragmento de código y responde a la solicitud con información sobre cómo recuperar el fragmento de código mediante la getSnippets herramienta . De nuevo, puede revisar la ejecución de la función en los registros y comprobar que se ejecutó la saveSnippets función.
En el chat de Copilot, utilice la indicación:
```
Retrieve snippet1 and apply to NewFile
```
Copilot recupera los fragmentos de código, lo agrega a un archivo denominado NewFiley hace lo que sea necesario para que el fragmento de código funcione en el proyecto. Los registros de funciones muestran que se llamó al getSnippets endpoint.
Cuando haya terminado de probar, presione Ctrl+C para detener el host de Functions.

Revisión del código (opcional)

Puede revisar el código que define las herramientas del servidor MCP:

El código de función de las herramientas de servidor MCP se define en la src carpeta . El McpToolTrigger atributo expone las funciones como herramientas del servidor MCP:

[Function(nameof(SayHello))]
public string SayHello(
    [McpToolTrigger(HelloToolName, HelloToolDescription)] ToolInvocationContext context
)
{
    logger.LogInformation("Saying hello");
    return "Hello I am MCP Tool!";
}

    [Function(nameof(GetSnippet))]
    public object GetSnippet(
        [McpToolTrigger(GetSnippetToolName, GetSnippetToolDescription)]
            ToolInvocationContext context,
        [BlobInput(BlobPath)] string snippetContent
    )
    {
        return snippetContent;
    }

    [Function(nameof(SaveSnippet))]
    [BlobOutput(BlobPath)]
    public string SaveSnippet(
        [McpToolTrigger(SaveSnippetToolName, SaveSnippetToolDescription)]
            ToolInvocationContext context,
        [McpToolProperty(SnippetNamePropertyName, SnippetNamePropertyDescription, true)]
            string name,
        [McpToolProperty(SnippetPropertyName, SnippetPropertyDescription, true)]
            string snippet
    )
    {
        return snippet;
    }
}

Puede ver la plantilla de proyecto completa en el repositorio de GitHub del servidor MCP de .NET de Azure Functions .

El código de función de las herramientas de servidor MCP se define en la src/main/java/com/function/ carpeta . La @McpToolTrigger anotación expone las funciones como herramientas de servidor MCP:

            description = "The messages to be logged.",
            isRequired = true,
            isArray = true)
        String messages,
        final ExecutionContext functionExecutionContext
) {
    functionExecutionContext.getLogger().info("Hello, World!");
    functionExecutionContext.getLogger().info("Tool Name: " + mcpToolInvocationContext.getName());
    functionExecutionContext.getLogger().info("Transport Type: " + mcpToolInvocationContext.getTransportType());
    
    // Handle different transport types
    if (mcpToolInvocationContext.isHttpStreamable()) {
        functionExecutionContext.getLogger().info("Session ID: " + mcpToolInvocationContext.getSessionid());
    } else if (mcpToolInvocationContext.isHttpSse()) {
        if (mcpToolInvocationContext.getClientinfo() != null) {
            functionExecutionContext.getLogger().info("Client: " + 
                mcpToolInvocationContext.getClientinfo().get("name").getAsString() + " v" +

    // Write the snippet content to the output blob
    outputBlob.setValue(snippet);
    
    return "Successfully saved snippet '" + snippetName + "' with " + snippet.length() + " characters.";
}

/**
 * Azure Function that handles retrieving a text snippet from Azure Blob Storage.
 * <p>
 * The function is triggered by an MCP Tool Trigger. The snippet name is provided
 * as an MCP tool property, and the snippet content is read from the blob at the 
 * path derived from the snippet name.
 *
 * @param mcpToolInvocationContext The JSON input from the MCP tool trigger.
 * @param snippetName   The name of the snippet to retrieve, provided as an MCP tool property.
 * @param inputBlob     The Azure Blob input binding that fetches the snippet content.
 * @param functionExecutionContext       The execution context for logging.
 */
@FunctionName("GetSnippets")
@StorageAccount("AzureWebJobsStorage")
public String getSnippet(
        @McpToolTrigger(
            name = "getSnippets",
            description = "Gets a text snippet from your snippets collection.")
        String mcpToolInvocationContext,
        @McpToolProperty(
            name = SNIPPET_NAME_PROPERTY_NAME,
            propertyType = "string",
            description = "The name of the snippet.",
            isRequired = true)
        String snippetName,
        @BlobInput(name = "inputBlob", path = BLOB_PATH)
        String inputBlob,
        final ExecutionContext functionExecutionContext
) {
    // Log the entire incoming JSON for debugging
    functionExecutionContext.getLogger().info(mcpToolInvocationContext);

    // Log the snippet name and the fetched snippet content from the blob

Puede ver la plantilla de proyecto completa en el repositorio de GitHub de Azure Functions Java MCP Server.

El código de función para las herramientas de servidor MCP se define en el src/function_app.py archivo . Las anotaciones de la función MCP exponen estas funciones como herramientas del servidor MCP:

tool_properties_save_snippets_json = json.dumps([prop.to_dict() for prop in tool_properties_save_snippets_object])
tool_properties_get_snippets_json = json.dumps([prop.to_dict() for prop in tool_properties_get_snippets_object])


@app.generic_trigger(
    arg_name="context",
    type="mcpToolTrigger",
    toolName="hello_mcp",
    description="Hello world.",
    toolProperties="[]",
)
def hello_mcp(context) -> None:
    """


@app.generic_trigger(
    arg_name="context",
    type="mcpToolTrigger",
    toolName="save_snippet",
    description="Save a snippet with a name.",
    toolProperties=tool_properties_save_snippets_json,
)
@app.generic_output_binding(arg_name="file", type="blob", connection="AzureWebJobsStorage", path=_BLOB_PATH)
def save_snippet(file: func.Out[str], context) -> str:
    content = json.loads(context)
    snippet_name_from_args = content["arguments"][_SNIPPET_NAME_PROPERTY_NAME]
    snippet_content_from_args = content["arguments"][_SNIPPET_PROPERTY_NAME]

    if not snippet_name_from_args:
        return "No snippet name provided"

    if not snippet_content_from_args:
        return "No snippet content provided"

    file.set(snippet_content_from_args)
    logging.info(f"Saved snippet: {snippet_content_from_args}")
    return f"Snippet '{snippet_content_from_args}' saved successfully"

Puede ver la plantilla de proyecto completa en el repositorio de GitHub del servidor MCP de Python de Azure Functions .

El código de función de las herramientas de servidor MCP se define en la src carpeta . El registro de funciones de MCP expone estas funciones como herramientas del servidor MCP:

export async function mcpToolHello(_toolArguments:unknown, context: InvocationContext): Promise<string> {
    console.log(_toolArguments);
    // Get name from the tool arguments
    const mcptoolargs = context.triggerMetadata.mcptoolargs as {
        name?: string;
    };
    const name = mcptoolargs?.name;

    console.info(`Hello ${name}, I am MCP Tool!`);
    
    return `Hello ${name || 'World'}, I am MCP Tool!`;
}

// Register the hello tool
app.mcpTool('hello', {
    toolName: 'hello',
    description: 'Simple hello world MCP Tool that responses with a hello message.',
    toolProperties:{
        name: arg.string().describe('Required property to identify the caller.').optional()
    },
    handler: mcpToolHello
});

// SaveSnippet function - saves a snippet with a name
export async function saveSnippet(
  _toolArguments: unknown,
  context: InvocationContext
): Promise<string> {
  console.info("Saving snippet");

  // Get snippet name and content from the tool arguments
  const mcptoolargs = context.triggerMetadata.mcptoolargs as {
    snippetname?: string;
    snippet?: string;
  };

  const snippetName = mcptoolargs?.snippetname;
  const snippet = mcptoolargs?.snippet;

  if (!snippetName) {
    return "No snippet name provided";
  }

  if (!snippet) {
    return "No snippet content provided";
  }

  // Save the snippet to blob storage using the output binding
  context.extraOutputs.set(blobOutputBinding, snippet);

  console.info(`Saved snippet: ${snippetName}`);
  return snippet;
}

Puede ver la plantilla de proyecto completa en el repositorio de GitHub del servidor MCP de Azure Functions TypeScript .

Después de comprobar las herramientas del servidor MCP localmente, puede publicar el proyecto en Azure.

Implementación en Azure

Este proyecto está configurado para usar el comando azd up para implementar este proyecto en una nueva aplicación de funciones en un Plan de consumo flexible en Azure. El proyecto incluye un conjunto de archivos de Bicep que azd usa para crear una implementación segura en un plan de consumo Flex que sigue los procedimientos recomendados.

En Visual Studio Code, presione F1 para abrir la paleta de comandos. Busque y ejecute el comando Azure Developer CLI (azd): Package, Provison and Deploy (up). A continuación, inicie sesión con su cuenta de Azure.
Si aún no ha iniciado sesión, autentíquese con su cuenta de Azure.

Cuando se le solicite, proporcione estos parámetros de implementación necesarios:

Parámetro	Description
Suscripción a Azure	Suscripción en la que se crean los recursos.
Ubicación de Azure	Región de Azure en la que se va a crear el grupo de recursos que contiene los nuevos recursos de Azure. Solo se muestran las regiones que admiten actualmente el Plan de consumo flexible.

Una vez que el comando se complete correctamente, verá vínculos a los recursos que creó.

Conexión al servidor MCP remoto

El servidor MCP ahora se está ejecutando en Azure. Al acceder a las herramientas, debe incluir una clave del sistema en la solicitud. Esta clave proporciona un grado de control de acceso para los clientes que acceden al servidor MCP remoto. Después de obtener esta clave, puede conectar GitHub Copilot al servidor remoto.

Ejecute este script que usa azd y la CLI de Azure para imprimir tanto la dirección URL del servidor MCP como la clave del sistema (mcp_extension) necesaria para acceder a las herramientas:

Linux/macOS
Windows

eval $(azd env get-values --output dotenv)
MCP_EXTENSION_KEY=$(az functionapp keys list --resource-group $AZURE_RESOURCE_GROUP \
    --name $AZURE_FUNCTION_NAME --query "systemKeys.mcp_extension" -o tsv)
printf "MCP Server URL: %s\n" "https://$SERVICE_API_NAME.azurewebsites.net/runtime/webhooks/mcp"
printf "MCP Server key: %s\n" "$MCP_EXTENSION_KEY"

azd env get-values --output dotenv | ForEach-Object { 
    if ($_ -match "^([^=]+)=(.*)$") { 
        Set-Variable -Name $matches[1] -Value ($matches[2] -replace '"', '')
    } 
}
$MCP_EXTENSION_KEY = az functionapp keys list --resource-group $AZURE_RESOURCE_GROUP `
    --name $AZURE_FUNCTION_NAME --query "systemKeys.mcp_extension" -o tsv
Write-Host "MCP Server URL: https://$SERVICE_API_NAME.azurewebsites.net/runtime/webhooks/mcp"
Write-Host "MCP Server key: $MCP_EXTENSION_KEY"

En Visual Studio Code, presione F1 para abrir la paleta de comandos, busque y ejecute el comando MCP: Open Workspace Folder MCP Configuraton, que abre el archivo de mcp.json configuración.

En la configuración mcp.json, busque el servidor MCP con nombre que agregó anteriormente, cambie el valor url a la dirección URL del servidor MCP remoto y agregue un elemento headers.x-functions-key, que contiene la clave de acceso del servidor MCP copiada, como en este ejemplo:

{
    "servers": {
        "remote-mcp-function": {
            "type": "http",
            "url": "https://contoso.azurewebsites.net/runtime/webhooks/mcp",
            "headers": {
                "x-functions-key": "A1bC2dE3fH4iJ5kL6mN7oP8qR9sT0u..."
            }
        }
    }
}

Seleccione el botón Iniciar situado encima del nombre del mcp.json servidor abierto para reiniciar el servidor MCP remoto, esta vez con la aplicación implementada.

Comprobación de la implementación

Ahora puede hacer que GitHub Copilot use las herramientas de MCP remotas como lo hizo localmente, pero ahora el código se ejecuta de forma segura en Azure. Reproduzca los mismos comandos que usó anteriormente para asegurarse de que todo funciona correctamente.

Limpieza de recursos

Cuando haya terminado de trabajar con el servidor MCP y los recursos relacionados, use este comando para eliminar la aplicación de funciones y sus recursos relacionados de Azure para evitar incurrir en costos adicionales:

azd down --no-prompt

Nota:

La --no-prompt opción indica azd que elimine el grupo de recursos sin confirmación de usted. Este comando no afecta al proyecto de código local.

Pasos siguientes

Configuración de la autorización del servidor MCP integrada

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-12-01