Compartir a través de

Introducción al servidor MCP de Microsoft Sentinel

Importante

Parte de la información contenida en este artículo se refiere a un producto preliminar que puede sufrir modificaciones sustanciales antes de su lanzamiento comercial. Microsoft no otorga garantías, expresas o implícitas, con respecto a la información que aquí se proporciona.

La colección de herramientas de creación de agentes en el servidor de Protocolo de contexto de modelo (MCP) de Microsoft Sentinel permite a los desarrolladores usar lenguaje natural para compilar Security Copilot agentes dentro de un IDE compatible con MCP que prefiera.

En esta introducción, aprenderá a:

  • Configuración y autenticación en el servidor MCP

  • Habilitación del modo de agente de GitHub Copilot

  • Administración del contexto de las herramientas de MCP

Requisitos previos

Para usar el servidor MCP de Microsoft Sentinel y acceder a las herramientas, debe incorporarse a lago de datos de Microsoft Sentinel. Para obtener más información, consulte Incorporación a lago de datos de Microsoft Sentinel y Microsoft Sentinel Graph (versión preliminar).

Editores de código admitidos

La compatibilidad de Microsoft Sentinel con las herramientas mcp de creación de agentes de Security Copilot está disponible para los siguientes editores de código con tecnología de inteligencia artificial:

Configuración y autenticación en el servidor MCP

Los pasos para instalar el servidor MCP son los siguientes:

  1. Inicie Visual Studio Code (VS Code).

  2. Agregue la conexión del servidor MCP en VS Code. Tipo Presione Ctrl + Shift + P para abrir la paleta de comandos. Escriba el símbolo >, seguido del texto MCP: Add server.

    Imagen para agregar un servidor MCP en vs code

  3. Seleccione HTTP (HTTP or Server-Sent Events).

    Imagen para seleccionar la opción http SSE en el código VS

  4. Escriba la siguiente dirección URL del servidor y seleccione Entrar. Esta dirección URL distingue mayúsculas de minúsculas.

        https://sentinel.microsoft.com/mcp/security-copilot-agent-creation

  5. Escriba un identificador de servidor descriptivo.

    Imagen para agregar un identificador de servidor personalizado en el código VS

  6. Se le pedirá que confíe en el servidor.

    Imagen para seleccionar Servidor de confianza en vs code

  7. Seleccione Permitir cuando se le pida que autentique la definición del servidor.

    Imagen para seleccionar permitir que el servidor se autentique en Security Copilot

  8. Elija si desea que el servidor esté disponible en todas las áreas de trabajo de VS Code o solo en la actual.

    Imagen para seleccionar áreas de trabajo en vs code

  9. Una vez autenticado, el servidor debe empezar a ejecutarse y debería ver un archivo denominado mcp.json que comprueba las configuraciones del servidor MCP en el área de trabajo de VS Code.

    Imagen para mostrar que se ha iniciado la ejecución del servidor MCP

Habilitación del modo de agente de GitHub Copilot

  1. Abra el menú >Vista de chat > de VS Code Chat o presione CRTL + ALT + I.

  2. Establezca el chat en modo agente.

    Imagen para mostrar el modo de agente en el chat

  3. Seleccione el icono de herramientas en la barra de mensajes.

    Imagen para mostrar las herramientas del agente en el chat

  4. Puede ver una lista de las herramientas que usa GitHub Copilot. Expanda la fila del servidor MCP que acaba de agregar para ver las cinco herramientas para la creación de agentes:

    Imagen para mostrar las herramientas de lista de servidores MCP

Administración del contexto de las herramientas de MCP

Al proporcionar el contexto adecuado, puede obtener ayuda de la inteligencia artificial en VS Code para proporcionar respuestas pertinentes y precisas. En esta sección se tratan dos opciones para administrar el contexto y asegurarse de que la inteligencia artificial asistente usa las herramientas de MCP según lo previsto y con mayor coherencia.

Puede elegir entre una de las siguientes opciones para administrar el contexto:

  1. Instrucciones personalizadas

  2. Agregar archivo de contexto

Instrucciones personalizadas

Las instrucciones personalizadas permiten definir directrices o reglas comunes en un archivo Markdown para describir cómo se deben realizar las tareas. En lugar de incluir manualmente el contexto en cada mensaje de chat, especifique instrucciones personalizadas en un archivo Markdown para garantizar respuestas de IA coherentes que se ajusten a los requisitos del proyecto.

Puede configurar instrucciones personalizadas para que se apliquen automáticamente a todas las solicitudes de chat o solo a archivos específicos.

Uso de un archivo de instrucciones personalizado

Defina las instrucciones personalizadas en un único .github/copilot-instructions.md archivo Markdown en la raíz del área de trabajo. VS Code aplica automáticamente las instrucciones de este archivo a todas las solicitudes de chat dentro de este área de trabajo.

Los pasos para usar un .github/copilot-instructions.md archivo:

  1. Habilite la github.copilot.chat.codeGeneration.useInstructionFiles configuración.

  2. Cree un .github/copilot-instructions.md archivo en la raíz del área de trabajo. Si es necesario, cree primero un .github directorio.

    Imagen para agregar instrucciones personalizadas para administrar el contexto en vs code

  3. Describa las instrucciones mediante el lenguaje natural y en formato Markdown.

  4. Para empezar, copie el contenido del archivo scp-mcp-context.md de contexto en el copilot-instructions.md archivo . Consulte contexto de MCP.

Agregar archivo de contexto

Para ayudar a garantizar que la inteligencia artificial asistente pueda usar las herramientas de MCP según lo previsto y con mayor coherencia, agregue este archivo de contexto al IDE. Asegúrese de que la asistente de inteligencia artificial hace referencia a este archivo cuando lo solicita.

  1. Agregue el contexto scp-mcp-context.md a VS Code o péguelo directamente en el área de trabajo. Use el archivo de contexto, consulte contexto MCP. El área de trabajo tiene un aspecto similar al siguiente:

    Imagen para mostrar el archivo de contexto mcp agregado al área de trabajo

  2. Seleccione Agregar contexto en la barra de mensajes y seleccione el archivo de contexto.

    Imagen para mostrar el archivo de contexto MCP agregado en la barra de mensajes

Archivo de contexto para herramientas de MCP

Copie para scp-mcp-context.md usarlo con el inicio rápido.


# MCP Tools Available for Agent Building
    1. **start_agent_creation**
        - **Purpose**: Creates a new Security Copilot session and starts the agent building process.
        - The userQuery input will be the user's problem statement (what they want the agent to do).
        - The output of the tool should be returned IN FULL WITHOUT EDITS.
        - The tool will return an initial agent YAML definition.
    2. **compose_agent**
        - **Purpose**: Continues the session and agent building process created by *start_agent_creation*. Outputs agent definition YAML or can ask clarifying questions to the user.
        - The sessionId input is obtained from the output of *start_agent_creation*
        - The existingDefinition input is optional. If an agent definition YAML has not been created yet, this should be blank (can be an empty string).
    3. **search_for_tools**
        - **Purpose: Discover relevant skills (tools) based on the user's query
        - This will create a new Security Copilot session, but it should not be included in the start_agent/continue_agent flow.
          - A user might want to know about Security Copilot skills they have access to without wanting to create an agent
          - The session ID created should NOT be reused in any capacity
    4. **get_evaluation**
        - **Purpose: Get the results of the evaluations triggered by each of the above tools. You MUST repeatedly activate this tool until the property of the result "state" is equal to "Completed" in order to get the fully processed result. The "state" may equal "Created" or "Running" but again, you must repeat the process until the state is "Completed". There is NO MAXIMUM amount of times you might call this tool in a row.
    5. **deploy_agent**
        - **Purpose: Deploy an agent to Security Copilot.
        - The user must provide the scope as either "User" or "Workspace".
        - Unless they already have an AGENT definition yaml provided, *start_agent_creation* must be run before to generate an agentDefinition
        - "agentSkillsetName" should be COPIED EXACTLY from the value of "Descriptor: Name:" in the agent definition YAML, including any special characters like ".". This will NOT work if the two do not match EXACTLY.
        - DO NOT use *get_evaluation* after this tool.

# Agent Building Execution Flow

## Step 1: Problem Statement Check
- If the user did **not** provide a problem statement, prompt them to do so.
- If the user **did** provide a problem statement, proceed to Step 2.

## Step 2: Start Agent Creation
- Use the `start_agent_creation` tool with `userQuery = <problem statement>`.
  - **DO NOT** include any quotation marks in the userQuery
- Then, use `get_evaluation` to retrieve the initial response.
  - **DO** repeatedly call `get_evaluation` until the `"state"` property of the result equals `"Completed"`.
  - **DO NOT** require the user to ask again to get the results.
  - **DO NOT** edit or reword the response content.

## Step 2.5: Output Handling
- **DO NOT** reformat, summarize, or describe the YAML output.
- **DO** return the YAML output **verbatim**.
- **DO** return the output in **AGENT FORMAT**.

## Step 3: Agent Refinement
- Ask the user if they would like to edit the agent or if they would like to deploy the agent. If they want to deploy, skip to **Step 4**.
- If the user wants to edit the agent definition:
  - If they respond with edits directly, use `compose_agent` with:
    - `sessionId` from `start_agent_creation`
    - `existingDefinition = <previous AGENT YAML>`
      - `\n` MUST be rewritten as `\\n`
    - `userQuery = <user’s new input>`
      - **DO NOT** include any quotation marks in the userQuery
  - If they attach a manually edited YAML file to the context, use the file content as `existingDefinition`.
    - **DO NOT** edit the file directly, you MUST use `compose_agent`
    - `\n` MUST be rewritten as `\\n`

## Step 4: Agent Deployment
- If the user asks to deploy the agent, use `deploy_agent`.
  - You **must confirm the scope**: either `"User"` or `"Workspace"`.
    - If not provided, ask the user to specify.
  - `agentSkillsetName` must **exactly match** the value of `Descriptor: Name:` in the YAML.
    - This includes any special characters.
  - Leave existing instances of `\n` inside `agentDefinition` as-is
- **DO NOT** run `get_evaluation` after deployment.
- **DO** include all of these things in the tool response to the user:
    1. Confirm successful deployment to the user
    2. Direct the user to the Security Copilot portal to test and view the agent with this link: https://securitycopilot.microsoft.com/agents
    3. Direct the user to read more on how to test their agent in Security Copilot with this link: https://learn.microsoft.com/en-us/copilot/security/developer/mcp-quickstart#test-agent

## Step 5: Further Agent Refinement and Redeployment
- After deployment, the user may still want to **edit the agent definition**.
  - If so, you must support calling `compose_agent` again.
  - Follow the same process as described in **Step 3**:
    - If the user asks for edits directly, use the previous AGENT YAML as `existingDefinition`.
    - If the user uploads a manually edited YAML file, use the file content as `existingDefinition`.
- The user may also want to **redeploy the agent** after making refinements.
  - You must run `deploy_agent` again using the updated YAML.
  - Ensure the `agentSkillsetName` matches **exactly** the value of `Descriptor: Name:` in the latest YAML, including any special characters.
  - Leave existing instances of `\n` inside `agentDefinition` as-is
  - Confirm the deployment scope: either `"User"` or `"Workspace"`.
    - If the scope is not provided, prompt the user to specify.
  - Do **not** run `get_evaluation` after deployment.
  - Confirm successful redeployment to the user.
- Alternatively, the user may want to **create a new agent**.
  - Restart the procedure from **Step 1**.
  - When using `start_agent_creation`, a new session ID will be created.
  - **DO** keep track of which session IDs correspond to which problem statements or agents so the user can return to previous sessions if needed.

## Additional Rules
- Only call `compose_agent` **after** the user has provided a response. Do not proceed automatically.
- Agent creation must remain **user-driven**. Do not initiate steps without explicit user input.
- Wait for the user to respond before continuing to the next step.
- Tool responses must be returned **directly to the user** in full.
  - Do **not** alter, reformat, summarize, or reword the content of any tool response.
  - This applies specifically to the `"result": "content"` field in the JSON returned by tool executions.
  - LEAVE OUT any "Grounding Notes"

## Error Handling
- If any tool call fails:
  - Inform the user of the failure.
  - If it is a client error, make an attempt to retry the tools, rewriting inputs based on the error message.
    - Example: If the error indicates invalid JSON characters, escape or remove those characters from the input and retry. Always attempt escaping first.

Pasos siguientes

  • Last updated on