Inicio rápido: Compilación de aplicaciones de MCP mediante Azure Functions

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 10

• kit para desarrolladores de Java 17
  • Si usa otra versión compatible de Java, actualice el archivo del pom.xml proyecto.
  • Establezca la variable de entorno JAVA_HOME 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 22

• Python 3.11

• Node.js (necesario para compilar la interfaz de usuario de aplicaciones de MCP)

• Visual Studio Code con estas extensiones:

  • Extensión de Azure Functions. Esta extensión requiere Azure Functions Core Tools e intenta instalarlo cuando no esté disponible.

  • Extensión de Azure CLI para desarrolladores.

• Emulador Storage Azurite

• CLI de Azure. También puede ejecutar comandos de 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 la CLI de Azure Developer para crear un proyecto de código de Azure Functions a partir de una plantilla.

1. Desde un terminal, ejecute este azd init comando para crear un proyecto local a partir de la plantilla:

   azd init --template remote-mcp-functions-dotnet -e mcpweather-dotnet
   

   Este comando extrae los archivos del proyecto del repositorio template e inicializa el proyecto en una nueva carpeta. 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 nombres de los recursos que crea en Azure.

2. Cambie al directorio del proyecto:

   cd remote-mcp-functions-dotnet
   

1. Desde un terminal, ejecute este azd init comando para crear un proyecto local a partir de la plantilla:

   azd init --template remote-mcp-functions-typescript -e mcpweather-ts
   

   Este comando extrae los archivos del proyecto del repositorio template e inicializa el proyecto en una nueva carpeta. 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.

2. Cambie al directorio del proyecto:

   cd remote-mcp-functions-typescript
   

1. Desde un terminal, ejecute este azd init comando para crear un proyecto local a partir de la plantilla:

   azd init --template remote-mcp-functions-javascript -e mcpweather-js
   

   Este comando extrae los archivos del proyecto del repositorio template e inicializa el proyecto en una nueva carpeta. 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 nombres de los recursos que crea en Azure.

2. Cambie al directorio del proyecto:

   cd remote-mcp-functions-javascript
   

1. Desde un terminal, ejecute este azd init comando para crear un proyecto local a partir de la plantilla:

   azd init --template remote-mcp-functions-python -e mcpweather-python
   

   Este comando extrae los archivos del proyecto del repositorio template e inicializa el proyecto en una nueva carpeta. 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.

2. Cambie al directorio del proyecto:

   cd remote-mcp-functions-python
   

1. Desde un terminal, ejecute este azd init comando para crear un proyecto local a partir de la plantilla:

   azd init --template remote-mcp-functions-java -e mcpweather-java
   

   Este comando extrae los archivos del proyecto del repositorio template e inicializa el proyecto en una nueva carpeta. 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 nombres de los recursos que crea en Azure.

2. Cambie al directorio del proyecto:

   cd remote-mcp-functions-java
   

3. Abra el proyecto en Visual Studio Code:

   code .
   

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.

1. Si aún no lo ha hecho, instale Azurite.

2. Presione F1. En la paleta de comandos, busque y ejecute el comando Azurite: Start para iniciar el emulador de almacenamiento local.

Compilación de la interfaz de usuario de aplicaciones de MCP

La herramienta meteorológica mcP Apps incluye una aplicación de front-end que debe compilar antes de ejecutar el proyecto.

1. En el terminal, vaya a la carpeta de la aplicación de interfaz de usuario y compile la aplicación:

   cd src/McpWeatherApp/app
   npm install
   npm run build
   cd ../
   

1. En el terminal, vaya a la carpeta de la aplicación de interfaz de usuario y compile la aplicación:

   cd samples/McpWeatherApp/app
   npm install
   npm run build
   cd ..
   

1. En el terminal, vaya a la carpeta de la aplicación de interfaz de usuario y compile la aplicación:

   cd src/McpWeatherApp/app
   npm install
   npm run build
   cd ../../..
   

1. En el terminal, vaya a la carpeta de la aplicación de interfaz de usuario y compile la aplicación:

   cd src/app
   npm install
   npm run build
   cd ../..
   

1. En el terminal, vaya a la carpeta de la aplicación de interfaz de usuario y compile la aplicación:

   cd mcp-weather-app/src/app
   npm install
   npm run build
   cd ../../..
   

Ejecución local del servidor MCP

Cuando se le solicite, seleccione src/McpWeatherApp. Verá este mensaje porque hay dos proyectos en la solución y este artículo no usa el otro proyecto.

En una ventana de terminal, asegúrese de que está en la carpeta del samples/McpWeatherApp proyecto.

Visual Studio Code se integra con Azure Functions Core tools para permitirle ejecutar este proyecto en el equipo de desarrollo local. Para iniciar la aplicación de Functions localmente, presione F5 o seleccione 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 los nombres de las funciones que se ejecutan localmente.

Comprobación mediante GitHub Copilot

La plantilla de proyecto incluye un archivo .vscode/mcp.json que define un servidor local-mcp-function que apunta al punto de conexión local de MCP. Use esta configuración para comprobar el código mediante GitHub Copilot en Visual Studio Code:

1. Con la función que se ejecuta localmente, abra el .vscode/mcp.json archivo y seleccione el botón Iniciar situado encima de la local-mcp-function configuración.

2. En la ventana Copilot Chat, asegúrese de que está seleccionado el Agent, seleccione el Configurar herramientas y compruebe que MCP Server:local-mcp-function está habilitado en el chat.

3. Ejecute este comando:

   What's the weather in Seattle?
   

   Cuando se le pida que ejecute la herramienta, seleccione Permitir en este área de trabajo para que no tenga que seguir concediéndole permiso. La solicitud ejecuta la herramienta GetWeather, que devuelve datos meteorológicos. Dado que esta herramienta declara metadatos de la interfaz de usuario, el host de MCP también captura el recurso de interfaz de usuario y representa un widget meteorológico interactivo en un iframe de espacio aislado dentro del chat.

4. 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 de aplicaciones de MCP. Una herramienta mcp Apps requiere dos componentes:

• Herramienta con metadatos de interfaz de usuario que declara un ui.resourceUri que apunta a un recurso de interfaz de usuario.
• Recurso que sirve el CÓDIGO HTML o JavaScript agrupado en el URI coincidenteui://.

El código de función de la herramienta meteorológica mcP Apps se define en el src/functions/weatherMcpApp.js archivo . En esta función, la propiedad metadata de app.mcpTool() agrega metadatos de IU a la herramienta getWeather cuando se registra.

  metadata: TOOL_METADATA,
  handler: getWeather,
});

El getWeather controlador captura los datos meteorológicos de una ubicación y los devuelve como JSON.

  const location = mcptoolargs?.location ?? "";

  try {
    const result = await weatherService.getCurrentWeatherAsync(location);
    
    if ("TemperatureC" in result) {
      context.log(`Weather fetched for ${result.Location}: ${result.TemperatureC}°C`);
    } else {
      context.warn(`Weather error for ${result.Location}: ${result.Error}`);
    }

    return result;
  } catch (error) {
    context.error(`Failed to get weather for ${location}: ${error}`);
    return {
      Location: location || "Unknown",
      Error: `Unable to fetch weather: ${error instanceof Error ? error.message : String(error)}`,
      Source: "api.open-meteo.com"
    };
  }
}

// Register the GetWeatherWidget resource
app.mcpResource("getWeatherWidget", {
  uri: WEATHER_WIDGET_URI,
  resourceName: WEATHER_WIDGET_NAME,
  description: WEATHER_WIDGET_DESCRIPTION,

La app.mcpResource() función registra el getWeatherWidget controlador, que sirve al widget HTML.

  handler: getWeatherWidget,
});

// Register the GetWeather tool
// Note: metadata property is not yet supported in the JavaScript SDK for mcpTool
// The TOOL_METADATA is defined for future use when the SDK is updated
app.mcpTool("getWeather", {
  toolName: "GetWeather",
  description: "Returns current weather for a location via Open-Meteo.",
  toolProperties: {

El getWeatherWidget controlador lee y devuelve el archivo HTML agrupado.

  context.log("Getting weather widget");
  
  try {
    // __dirname is src/functions, go up 1 level to src/, then into app/dist
    const filePath = path.join(__dirname, "..", "app", "dist", "index.html");
    return fs.readFileSync(filePath, "utf-8");
  } catch (error) {
    context.log(`Error reading weather widget file: ${error}`);
    // Return a fallback HTML if file not found
    return `<!DOCTYPE html>
<html>
<head><title>Weather Widget</title></head>
<body>
  <h1>Weather Widget</h1>
  <p>Widget content not found. Please ensure the app/dist/index.html file exists.</p>
</body>
</html>`;
  }
}

// GetWeather function - returns current weather for a location
async function getWeather(_toolArguments, context) {
  context.log("Getting weather");

La TOOL_METADATA constante declara un ui.resourceUri que indica al host MCP que capture la interfaz de usuario interactiva de ui://weather/index.html después de que se ejecute la herramienta.

const TOOL_METADATA = JSON.stringify({
  ui: {
    resourceUri: "ui://weather/index.html"
  }
});

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

El código de función para la herramienta meteorológica de MCP Apps se define en la src/McpWeatherApp carpeta. En esta función, el [McpMetadata] atributo agrega metadatos de interfaz de usuario a la GetWeather herramienta.

[Function(nameof(GetWeather))]
public async Task<object> GetWeather(
    [McpToolTrigger(nameof(GetWeather), "Returns current weather for a location via Open-Meteo.")]
    [McpMetadata(ToolMetadata)]
        ToolInvocationContext context,
    [McpToolProperty("location", "City name to check weather for (e.g., Seattle, New York, Miami)")]
        string location)
{
    try
    {
        var result = await _weatherService.GetCurrentWeatherAsync(location);
        
        if (result is WeatherResult weather)
        {
            _logger.LogInformation("Weather fetched for {Location}: {TempC}°C", weather.Location, weather.TemperatureC);
        }
        else if (result is WeatherError error)
        {
            _logger.LogWarning("Weather error for {Location}: {Error}", error.Location, error.Error);
        }

        return result;
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Failed to get weather for {Location}", location);
        return new WeatherError(location ?? "Unknown", $"Unable to fetch weather: {ex.Message}", "api.open-meteo.com");
    }
}

El [McpResourceTrigger] atributo se aplica a la GetWeatherWidget función , que sirve al widget HTML.

[Function(nameof(GetWeatherWidget))]
public string GetWeatherWidget(
    [McpResourceTrigger(
        "ui://weather/index.html",
        "Weather Widget",
        MimeType = "text/html;profile=mcp-app",
        Description = "Interactive weather display for MCP Apps")]
    [McpMetadata(ResourceMetadata)]
        ResourceInvocationContext context)
{
    var file = Path.Combine(AppContext.BaseDirectory, "app", "dist", "index.html");
    return File.ReadAllText(file);
}

La ToolMetadata constante declara un ui.resourceUri que indica al host MCP que capture la interfaz de usuario interactiva de ui://weather/index.html después de que se ejecute la herramienta.

private const string ToolMetadata = """
    {
        "ui": {
            "resourceUri": "ui://weather/index.html"
        }
    }
    """;

La GetWeatherWidget función sirve el archivo HTML agrupado en ese URI mediante [McpResourceTrigger].

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

El código de función de la herramienta meteorológica mcP Apps se define en el src/McpWeatherApp/function_app.py archivo . En esta función, el metadata parámetro en @app.mcp_tool() agrega metadatos de interfaz de usuario a la get_weather herramienta.

# Get Weather Tool - returns current weather for a location
@app.mcp_tool(metadata=TOOL_METADATA)
@app.mcp_tool_property(arg_name="location", description="City name to check weather for (e.g., Seattle, New York, Miami)")
def get_weather(location: str) -> Dict[str, Any]:
    """Returns current weather for a location via Open-Meteo."""
    logging.info(f"Getting weather for location: {location}")
    
    try:
        result = weather_service.get_current_weather(location)
        
        if "TemperatureC" in result:
            logging.info(f"Weather fetched for {result['Location']}: {result['TemperatureC']}°C")
        else:
            logging.warning(f"Weather error for {result['Location']}: {result.get('Error', 'Unknown error')}")
        
        return json.dumps(result)
    except Exception as e:
        logging.error(f"Failed to get weather for {location}: {e}")
        return json.dumps({
            "Location": location or "Unknown",
            "Error": f"Unable to fetch weather: {str(e)}",
            "Source": "api.open-meteo.com"
        })

El @app.mcp_resource_trigger() decorador se aplica a la get_weather_widget función , que sirve al widget HTML.

@app.mcp_resource_trigger(
    arg_name="context",
    uri=WEATHER_WIDGET_URI,
    resource_name=WEATHER_WIDGET_NAME,
    description=WEATHER_WIDGET_DESCRIPTION,
    mime_type=WEATHER_WIDGET_MIME_TYPE,
    metadata=RESOURCE_METADATA
)
def get_weather_widget(context) -> str:
    """Get the weather widget HTML content."""
    logging.info("Getting weather widget")
    
    try:
        # Get the path to the widget HTML file
        # Current file is src/function_app.py, look for src/app/index.html
        current_dir = Path(__file__).parent
        file_path = current_dir / "app" / "dist" / "index.html"
        
        if file_path.exists():
            return file_path.read_text(encoding="utf-8")
        else:
            logging.warning(f"Weather widget file not found at: {file_path}")
            # Return a fallback HTML if file not found
            return """<!DOCTYPE html>
<html>
<head><title>Weather Widget</title></head>
<body>
  <h1>Weather Widget</h1>
  <p>Widget content not found. Please ensure the app/index.html file exists.</p>
</body>
</html>"""
    except Exception as e:
        logging.error(f"Error reading weather widget file: {e}")
        return """<!DOCTYPE html>
<html>
<head><title>Weather Widget Error</title></head>
<body>
  <h1>Weather Widget</h1>
  <p>Error loading widget content.</p>
</body>
</html>"""

La TOOL_METADATA constante declara un ui.resourceUri que indica al host MCP que capture la interfaz de usuario interactiva de ui://weather/index.html después de que se ejecute la herramienta.

TOOL_METADATA = json.dumps({"ui": {"resourceUri": "ui://weather/index.html"}})

La get_weather_widget función sirve el archivo HTML agrupado en ese URI mediante @app.mcp_resource_trigger().

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

El código de función de la herramienta meteorológica mcP Apps se define en el mcp-weather-app/src/functions/weatherMcpApp.ts archivo . En esta función, la propiedad metadata de app.mcpTool() agrega metadatos de IU a la herramienta getWeather cuando se registra.

// Register the GetWeather tool
app.mcpTool("getWeather", {
  toolName: "GetWeather",
  description: "Returns current weather for a location via Open-Meteo.",
  toolProperties: {
    location: arg.string().describe("City name to check weather for (e.g., Seattle, New York, Miami)")
  },
  metadata: TOOL_METADATA,
  handler: getWeather,
});

El getWeather controlador captura los datos meteorológicos de una ubicación y los devuelve como JSON.

// GetWeather function - returns current weather for a location
export async function getWeather(
  _toolArguments: unknown,
  context: InvocationContext
): Promise<object> {
  context.log("Getting weather");

  const mcptoolargs = context.triggerMetadata.mcptoolargs as {
    location?: string;
  };
  const location = mcptoolargs?.location ?? "";

  try {
    const result = await weatherService.getCurrentWeatherAsync(location);

    if ("TemperatureC" in result) {
      const weather = result as WeatherResult;
      context.log(`Weather fetched for ${weather.Location}: ${weather.TemperatureC}°C`);
    } else {
      const error = result as WeatherError;
      context.warn(`Weather error for ${error.Location}: ${error.Error}`);
    }

    return result;
  } catch (error) {
    context.error(`Failed to get weather for ${location}: ${error}`);
    return {
      Location: location || "Unknown",
      Error: `Unable to fetch weather: ${error instanceof Error ? error.message : String(error)}`,
      Source: "api.open-meteo.com"
    } as WeatherError;
  }
}

La app.mcpResource() función registra el getWeatherWidget controlador, que sirve al widget HTML.

// Register the GetWeatherWidget resource
app.mcpResource("getWeatherWidget", {
  uri: WEATHER_WIDGET_URI,
  resourceName: WEATHER_WIDGET_NAME,
  description: WEATHER_WIDGET_DESCRIPTION,
  mimeType: WEATHER_WIDGET_MIME_TYPE,
  metadata: RESOURCE_METADATA,
  handler: getWeatherWidget,
});

El getWeatherWidget controlador lee y devuelve el archivo HTML agrupado.

// GetWeatherWidget function - returns the HTML content for the weather widget
export async function getWeatherWidget(
  resourceContext: unknown,
  context: InvocationContext
): Promise<string> {
  context.log("Getting weather widget");

  try {
    // __dirname is dist/src/functions — go up 3 levels to project root, then to src/app/dist
    const filePath = path.join(__dirname, "..", "..", "..", "src", "app", "dist", "index.html");
    return fs.readFileSync(filePath, "utf-8");
  } catch (error) {
    context.log(`Error reading weather widget file: ${error}`);
    return `<!DOCTYPE html>
<html>
<head><title>Weather Widget</title></head>
<body>
  <h1>Weather Widget</h1>
  <p>Widget content not found. Run <code>npm run build:app</code> first.</p>
</body>
</html>`;
  }
}

La TOOL_METADATA constante declara un ui.resourceUri que indica al host MCP que capture la interfaz de usuario interactiva de ui://weather/index.html después de que se ejecute la herramienta.

// Metadata for the tool (as valid JSON string)
const TOOL_METADATA = JSON.stringify({
  ui: {
    resourceUri: "ui://weather/index.html"
  }
});

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

El código de función para la herramienta meteorológica de MCP Apps se define en la samples/McpWeatherApp carpeta. En esta función, la @McpMetadata anotación agrega metadatos de interfaz de usuario a la GetWeather herramienta.

    try (InputStream is = getClass().getClassLoader().getResourceAsStream("app/dist/index.html")) {
        if (is != null) {
            return new String(is.readAllBytes(), StandardCharsets.UTF_8);
        }
    } catch (IOException e) {
        executionContext.getLogger().log(Level.WARNING, "Failed to read UI from classpath", e);
    }

    return "<html><body><p>Weather widget UI not found. Run <code>npm run build</code> in the <code>app/</code> directory.</p></body></html>";
}

/**
 * MCP Tool: fetches current weather for a given location.
 * <p>
 * Returns structured weather data (JSON) that the MCP host can pass to the
 * UI resource declared in the tool metadata.
 */
@FunctionName("GetWeather")
public String getWeather(
        @McpToolTrigger(
                name = "GetWeather",
                description = "Returns current weather for a location via Open-Meteo.")
        @McpMetadata(
                name = "GetWeather",
                json = TOOL_METADATA)
        String context,
        @McpToolProperty(
                name = "location",
                propertyType = "string",
                description = "City name to check weather for (e.g., Seattle, New York, Miami)")
        String location,
        final ExecutionContext executionContext) {

    executionContext.getLogger().info("GetWeather: looking up weather for '" + location + "'");

La @McpResourceTrigger anotación se aplica a la GetWeatherWidget función , que sirve al widget HTML.

@FunctionName("GetWeatherWidget")
public String getWeatherWidget(
        @McpResourceTrigger(
                name = "context",
                uri = "ui://weather/index.html",
                resourceName = "Weather Widget",
                title = "Weather Widget",
                description = "Interactive weather display for MCP Apps",
                mimeType = "text/html;profile=mcp-app")
        @McpMetadata(
                name = "context",
                json = RESOURCE_METADATA)
        String context,
        final ExecutionContext executionContext) {

La TOOL_METADATA constante declara un ui.resourceUri que indica al host MCP que capture la interfaz de usuario interactiva de ui://weather/index.html después de que se ejecute la herramienta.

private static final String TOOL_METADATA = """
        {
            "ui": {
                "resourceUri": "ui://weather/index.html"
            }
        }
        """;

La GetWeatherWidget función sirve el archivo HTML agrupado en ese URI mediante @McpResourceTrigger.

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

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

Implementación en Azure

Este proyecto está configurado para usar azd 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 Bicep que azd usa para crear una implementación segura en un plan Consumo flexible que sigue los procedimientos recomendados.

1. En Visual Studio Code, presione F1 para abrir la paleta de comandos. Busque y ejecute el comando Azure Developer CLI (azd): Package, Provision and Deploy (up). A continuación, inicie sesión con su cuenta de Azure.

2. Cuando se le solicite, seleccione estos parámetros de implementación necesarios:

   Parámetro	Description
   Suscripción de 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.
   vnetEnabled	False para omitir la creación de recursos de red virtual, lo que simplifica la implementación.

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

Este proyecto está configurado para usar azd 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 Bicep que azd usa para crear una implementación segura en un plan Consumo flexible que sigue los procedimientos recomendados.

1. En el terminal, ejecute este azd env set comando:

   azd env set DEPLOY_SERVICE weather
   

   Este comando establece la variable para aprovisionar DEPLOY_SERVICE recursos relacionados con la weather aplicación.

2. Ejecute el azd provision comando y proporcione los parámetros necesarios para aprovisionar recursos:

   azd provision
   

   Parámetro	Description
   Suscripción de 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.
   vnetEnabled	False para omitir la creación de recursos de red virtual, lo que simplifica la implementación.

   Cuando se le solicite, elija la suscripción, una región de Azure para los recursos y elija false para omitir la creación de recursos de red virtual para simplificar la implementación.

3. Ejecute el comando azd deploy para implementar la aplicación weather en Azure:

   azd deploy --service weather
   

Conexión al servidor MCP remoto

El servidor MCP ahora se está ejecutando en Azure. La plantilla de proyecto incluye una remote-mcp-function entrada en .vscode/mcp.json que ya está configurada para conectarse al servidor remoto. Dado que la autorización MCP integrada está habilitada de forma predeterminada, Visual Studio Code controla el flujo de inicio de sesión de OAuth automáticamente al conectarse.

1. Obtén el nombre de la aplicación de funciones de tu implementación ejecutando este comando en el terminal:

   azd env get-value AZURE_FUNCTION_NAME
   

2. En .vscode/mcp.json, seleccione Iniciar encima de la remote-mcp-function configuración.

3. Cuando se le solicite, escriba el nombre de la aplicación de funciones del paso anterior.

4. Visual Studio Code le pide que inicie sesión con Microsoft Entra. Siga las indicaciones de autenticación para autorizar el acceso al servidor MCP remoto.

Comprobación de la implementación

Ahora puede hacer que GitHub Copilot use sus herramientas de MCP remotas tal como lo hacía localmente, pero 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