Freigeben über

Erste Schritte mit dem Microsoft Sentinel MCP-Server

Wichtig

Einige Informationen in diesem Artikel beziehen sich auf ein vorab veröffentlichtes Produkt, das vor der kommerziellen Veröffentlichung möglicherweise erheblich geändert wird. Microsoft übernimmt mit diesen Informationen keinerlei Gewährleistung, sei sie ausdrücklich oder konkludent.

Die Toolsammlung zum Erstellen des Agents auf dem MCP-Server (Microsoft Sentinel Model Context Protocol) ermöglicht Entwicklern die Verwendung natürlicher Sprache, um Security Copilot Agents innerhalb einer MCP-kompatiblen IDE Ihrer Wahl zu erstellen.

In diesen ersten Schritten erfahren Sie folgendes:

  • Einrichten und Authentifizieren beim MCP-Server

  • Aktivieren des GitHub Copilot-Agent-Modus

  • Verwalten des Kontexts für MCP-Tools

Voraussetzungen

Um Microsoft Sentinel MCP Server verwenden und auf die Tools zugreifen zu können, müssen Sie in Microsoft Sentinel-Data Lake integriert sein. Weitere Informationen finden Sie unter Onboarding in Microsoft Sentinel-Data Lake und Microsoft Sentinel Graph (Vorschau).

Unterstützte Code-Editoren

Die Unterstützung von Microsoft Sentinel für die MCP-Tools für die Security Copilot-Agent-Erstellung ist für die folgenden KI-gestützten Code-Editoren verfügbar:

Einrichten und Authentifizieren beim MCP-Server

Die Schritte zum Installieren des MCP-Servers lauten wie folgt:

  1. Starten Sie Visual Studio Code (VS Code).

  2. Fügen Sie die MCP-Serververbindung in VS Code hinzu. Geben Sie Drücken Ctrl + Shift + P ein, um die Befehlspalette zu öffnen. Geben Sie das Symbol >ein, gefolgt vom Text MCP: Add server.

    Abbildung zum Hinzufügen eines MCP-Servers in VS Code

  3. Wählen Sie aus HTTP (HTTP or Server-Sent Events).

    Abbildung zum Auswählen der OPTION

  4. Geben Sie die folgende Server-URL ein, und drücken Sie die EINGABETASTE. Bei dieser URL wird die Groß-/Kleinschreibung beachtet.

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

  5. Geben Sie eine benutzerfreundliche Server-ID ein.

    Abbildung zum Hinzufügen einer benutzerdefinierten Server-ID in VS Code

  6. Sie werden aufgefordert, dem Server zu vertrauen .

    Abbildung zum Auswählen des Vertrauensservers in VS Code

  7. Wählen Sie Zulassen aus, wenn Sie aufgefordert werden, die Serverdefinition zu authentifizieren.

    Image zum Auswählen der Authentifizierung des Servers bei Security Copilot

  8. Wählen Sie aus, ob der Server in allen VS Code-Arbeitsbereichen oder nur im aktuellen Arbeitsbereich verfügbar sein soll.

    Abbildung zum Auswählen von Arbeitsbereichen in VS Code

  9. Nach der Authentifizierung sollte der Server mit der Ausführung beginnen, und Es sollte eine Datei mit dem Namen mcp.json angezeigt werden, die im VS Code-Arbeitsbereich nach MCP-Serverkonfigurationen sucht.

    Abbildung, die zeigt, dass die MCP-Serverausführung gestartet wurde

Aktivieren des GitHub Copilot-Agent-Modus

  1. Öffnen Sie das Chatansichtsmenü>> Chat von VS Code, oder drücken Sie CRTL + ALT + I.

  2. Legen Sie den Chat auf den Agent-Modus fest.

    Abbildung zum Anzeigen des Agent-Modus im Chat

  3. Wählen Sie das Toolsymbol in der Eingabeaufforderungsleiste aus.

    Abbildung zum Anzeigen der Agent-Tools im Chat

  4. Sie können eine Liste der Tools anzeigen, die von GitHub Copilot verwendet werden. Erweitern Sie die Zeile für den MCP-Server, den Sie gerade hinzugefügt haben, um die fünf Tools für die Agenterstellung anzuzeigen:

    Abbildung der MCP-Serverlistentools

Verwalten des Kontexts für MCP-Tools

Indem Sie den richtigen Kontext bereitstellen, können Sie hilfe von KI in VS Code erhalten, um relevante und genaue Antworten zu liefern. In diesem Abschnitt werden zwei Optionen behandelt, mit denen Sie den Kontext verwalten und sicherstellen können, dass die KI-Assistent die MCP-Tools wie beabsichtigt und mit größerer Konsistenz verwendet.

Sie können eine der folgenden Optionen zum Verwalten des Kontexts auswählen:

  1. Benutzerdefinierte Anweisungen

  2. Hinzufügen einer Kontextdatei

Benutzerdefinierte Anweisungen

Mit benutzerdefinierten Anweisungen können Sie allgemeine Richtlinien oder Regeln in einer Markdowndatei definieren, um zu beschreiben, wie Aufgaben ausgeführt werden sollten. Anstatt den Kontext manuell in jede Chataufforderung einzugeben, geben Sie benutzerdefinierte Anweisungen in einer Markdowndatei an, um konsistente KI-Antworten sicherzustellen, die Ihren Projektanforderungen entsprechen.

Sie können benutzerdefinierte Anweisungen so konfigurieren, dass sie automatisch auf alle Chatanfragen oder nur auf bestimmte Dateien angewendet werden.

Verwenden einer benutzerdefinierten Anweisungsdatei

Definieren Sie Ihre benutzerdefinierten Anweisungen in einer einzelnen .github/copilot-instructions.md Markdowndatei im Stammverzeichnis Ihres Arbeitsbereichs. VS Code wendet die Anweisungen in dieser Datei automatisch auf alle Chatanfragen in diesem Arbeitsbereich an.

Die Schritte zum Verwenden einer .github/copilot-instructions.md Datei:

  1. Aktivieren Sie die github.copilot.chat.codeGeneration.useInstructionFiles Einstellung.

  2. Erstellen Sie eine .github/copilot-instructions.md Datei im Stammverzeichnis Ihres Arbeitsbereichs. Erstellen Sie bei Bedarf zuerst ein .github Verzeichnis.

    Abbildung zum Hinzufügen benutzerdefinierter Anweisungen zum Verwalten des Kontexts in VS Code

  3. Beschreiben Sie Ihre Anweisungen in natürlicher Sprache und im Markdownformat.

  4. Kopieren Sie zunächst den Inhalt der Kontextdatei scp-mcp-context.md in die copilot-instructions.md Datei. Siehe MCP-Kontext.

Hinzufügen einer Kontextdatei

Um sicherzustellen, dass die KI-Assistent die MCP-Tools wie beabsichtigt und mit größerer Konsistenz verwenden können, fügen Sie diese Kontextdatei Ihrer IDE hinzu. Stellen Sie sicher, dass der KI-Assistent auf diese Datei verweist, wenn Sie dazu aufgefordert werden.

  1. Fügen Sie den Kontext scp-mcp-context.md zu VS Code hinzu, oder fügen Sie ihn direkt in Ihren Arbeitsbereich ein. Verwenden Sie die Kontextdatei, siehe MCP-Kontext. Ihr Arbeitsbereich sieht in etwa wie folgt aus:

    Abbildung, die die MCP-Kontextdatei zeigt, die dem Arbeitsbereich hinzugefügt wurde

  2. Wählen Sie in der Eingabeaufforderungsleiste Kontext hinzufügen und dann die Kontextdatei aus.

    Abbildung zur Anzeige der MCP-Kontextdatei, die in der Eingabeaufforderungsleiste hinzugefügt wurde

Kontextdatei für MCP-Tools

Kopieren Sie den scp-mcp-context.md für den Schnellstart.


# 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.

Nächste Schritte

  • Last updated on