Delen via

GitHub Copilot-Agents

Microsoft Agent Framework biedt ondersteuning voor het maken van agents die gebruikmaken van de GitHub Copilot SDK als back-end. GitHub Copilot-agents bieden toegang tot krachtige coderingsgerichte AI-mogelijkheden, waaronder uitvoering van shell-opdrachten, bestandsbewerkingen, URL-ophalen en MCP-serverintegratie (Model Context Protocol).

Belangrijk

GitHub Copilot-agents vereisen dat de GitHub Copilot CLI is geïnstalleerd en geverifieerd. Voor beveiliging is het raadzaam om agents uit te voeren met shell- of bestandsmachtigingen in een containeromgeving (Docker/Dev Container).

Aan de slag komen

Voeg de vereiste NuGet-pakketten toe aan uw project.

dotnet add package Microsoft.Agents.AI.GitHub.Copilot --prerelease

Een GitHub Copilot-agent maken

Als eerste stap maakt u een CopilotClient en start deze. Gebruik vervolgens de AsAIAgent extensiemethode om een agent te maken.

using GitHub.Copilot.SDK;
using Microsoft.Agents.AI;

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

AIAgent agent = copilotClient.AsAIAgent();

Console.WriteLine(await agent.RunAsync("What is Microsoft Agent Framework?"));

Met hulpprogramma's en instructies

U kunt functiehulpprogramma's en aangepaste instructies opgeven bij het maken van de agent:

using GitHub.Copilot.SDK;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

AIFunction weatherTool = AIFunctionFactory.Create((string location) =>
{
    return $"The weather in {location} is sunny with a high of 25C.";
}, "GetWeather", "Get the weather for a given location.");

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

AIAgent agent = copilotClient.AsAIAgent(
    tools: [weatherTool],
    instructions: "You are a helpful weather agent.");

Console.WriteLine(await agent.RunAsync("What's the weather like in Seattle?"));

Agent functies

Streamingreacties

Antwoorden ophalen terwijl ze worden gegenereerd:

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

AIAgent agent = copilotClient.AsAIAgent();

await foreach (AgentResponseUpdate update in agent.RunStreamingAsync("Tell me a short story."))
{
    Console.Write(update);
}

Console.WriteLine();

Sessiebeheer

De gesprekscontext onderhouden voor meerdere interacties met behulp van sessies:

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

await using GitHubCopilotAgent agent = new(
    copilotClient,
    instructions: "You are a helpful assistant. Keep your answers short.");

AgentSession session = await agent.CreateSessionAsync();

// First turn
await agent.RunAsync("My name is Alice.", session);

// Second turn - agent remembers the context
AgentResponse response = await agent.RunAsync("What is my name?", session);
Console.WriteLine(response); // Should mention "Alice"

Permissions

De agent kan standaard geen shellopdrachten uitvoeren, bestanden lezen/schrijven of URL's ophalen. Als u deze mogelijkheden wilt inschakelen, geeft u een machtigingshandler op via SessionConfig:

static Task<PermissionRequestResult> PromptPermission(
    PermissionRequest request, PermissionInvocation invocation)
{
    Console.WriteLine($"\n[Permission Request: {request.Kind}]");
    Console.Write("Approve? (y/n): ");

    string? input = Console.ReadLine()?.Trim().ToUpperInvariant();
    string kind = input is "Y" or "YES" ? "approved" : "denied-interactively-by-user";

    return Task.FromResult(new PermissionRequestResult { Kind = kind });
}

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

SessionConfig sessionConfig = new()
{
    OnPermissionRequest = PromptPermission,
};

AIAgent agent = copilotClient.AsAIAgent(sessionConfig);

Console.WriteLine(await agent.RunAsync("List all files in the current directory"));

MCP-servers

Maak verbinding met lokale (stdio) of externe (HTTP) MCP-servers voor uitgebreide mogelijkheden:

await using CopilotClient copilotClient = new();
await copilotClient.StartAsync();

SessionConfig sessionConfig = new()
{
    OnPermissionRequest = PromptPermission,
    McpServers = new Dictionary<string, object>
    {
        // Local stdio server
        ["filesystem"] = new McpLocalServerConfig
        {
            Type = "stdio",
            Command = "npx",
            Args = ["-y", "@modelcontextprotocol/server-filesystem", "."],
            Tools = ["*"],
        },
        // Remote HTTP server
        ["microsoft-learn"] = new McpRemoteServerConfig
        {
            Type = "http",
            Url = "https://learn.microsoft.com/api/mcp",
            Tools = ["*"],
        },
    },
};

AIAgent agent = copilotClient.AsAIAgent(sessionConfig);

Console.WriteLine(await agent.RunAsync("Search Microsoft Learn for 'Azure Functions' and summarize the top result"));

Aanbeveling

Zie de .NET-voorbeelden voor volledige runnable voorbeelden.

De agent gebruiken

De agent is een standaard AIAgent en ondersteunt alle standaard AIAgent bewerkingen.

Voor meer informatie over hoe je agents uitvoert en ermee werkt, raadpleeg de Aan de slag met agent-tutorials.

Vereiste voorwaarden

Installeer het GitHub Copilot-pakket van Microsoft Agent Framework.

pip install agent-framework-github-copilot --pre

Configuratie

De agent kan eventueel worden geconfigureerd met behulp van de volgende omgevingsvariabelen:

Variable Description
GITHUB_COPILOT_CLI_PATH Pad naar het uitvoerbare Copilot CLI-bestand
GITHUB_COPILOT_MODEL Model dat moet worden gebruikt (bijvoorbeeld gpt-5, claude-sonnet-4)
GITHUB_COPILOT_TIMEOUT Time-out aanvragen in seconden
GITHUB_COPILOT_LOG_LEVEL CLI-logboekniveau

Aan de slag komen

Importeer de vereiste klassen uit Agent Framework:

import asyncio
from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions

Een GitHub Copilot-agent maken

Basisagent maken

De eenvoudigste manier om een GitHub Copilot-agent te maken:

async def basic_example():
    agent = GitHubCopilotAgent(
        default_options={"instructions": "You are a helpful assistant."},
    )

    async with agent:
        result = await agent.run("What is Microsoft Agent Framework?")
        print(result)

Met expliciete configuratie

U kunt expliciete configuratie opgeven via default_options:

async def explicit_config_example():
    agent = GitHubCopilotAgent(
        default_options={
            "instructions": "You are a helpful assistant.",
            "model": "gpt-5",
            "timeout": 120,
        },
    )

    async with agent:
        result = await agent.run("What can you do?")
        print(result)

Agent functies

Functiehulpmiddelen

Uw agent voorzien van aangepaste functies:

from typing import Annotated
from pydantic import Field

def get_weather(
    location: Annotated[str, Field(description="The location to get the weather for.")],
) -> str:
    """Get the weather for a given location."""
    return f"The weather in {location} is sunny with a high of 25C."

async def tools_example():
    agent = GitHubCopilotAgent(
        default_options={"instructions": "You are a helpful weather agent."},
        tools=[get_weather],
    )

    async with agent:
        result = await agent.run("What's the weather like in Seattle?")
        print(result)

Streamingreacties

Antwoorden ophalen wanneer ze worden gegenereerd voor een betere gebruikerservaring:

async def streaming_example():
    agent = GitHubCopilotAgent(
        default_options={"instructions": "You are a helpful assistant."},
    )

    async with agent:
        print("Agent: ", end="", flush=True)
        async for chunk in agent.run("Tell me a short story.", stream=True):
            if chunk.text:
                print(chunk.text, end="", flush=True)
        print()

Threadbeheer

Gesprekscontext onderhouden voor meerdere interacties:

async def thread_example():
    agent = GitHubCopilotAgent(
        default_options={"instructions": "You are a helpful assistant."},
    )

    async with agent:
        thread = agent.create_session()

        # First interaction
        result1 = await agent.run("My name is Alice.", session=thread)
        print(f"Agent: {result1}")

        # Second interaction - agent remembers the context
        result2 = await agent.run("What's my name?", session=thread)
        print(f"Agent: {result2}")  # Should remember "Alice"

Permissions

De agent kan standaard geen shellopdrachten uitvoeren, bestanden lezen/schrijven of URL's ophalen. Als u deze mogelijkheden wilt inschakelen, geeft u een machtigingshandler op:

from copilot.types import PermissionRequest, PermissionRequestResult

def prompt_permission(
    request: PermissionRequest, context: dict[str, str]
) -> PermissionRequestResult:
    kind = request.get("kind", "unknown")
    print(f"\n[Permission Request: {kind}]")

    response = input("Approve? (y/n): ").strip().lower()
    if response in ("y", "yes"):
        return PermissionRequestResult(kind="approved")
    return PermissionRequestResult(kind="denied-interactively-by-user")

async def permissions_example():
    agent = GitHubCopilotAgent(
        default_options={
            "instructions": "You are a helpful assistant that can execute shell commands.",
            "on_permission_request": prompt_permission,
        },
    )

    async with agent:
        result = await agent.run("List the Python files in the current directory")
        print(result)

MCP-servers

Maak verbinding met lokale (stdio) of externe (HTTP) MCP-servers voor uitgebreide mogelijkheden:

from copilot.types import MCPServerConfig

async def mcp_example():
    mcp_servers: dict[str, MCPServerConfig] = {
        # Local stdio server
        "filesystem": {
            "type": "stdio",
            "command": "npx",
            "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
            "tools": ["*"],
        },
        # Remote HTTP server
        "microsoft-learn": {
            "type": "http",
            "url": "https://learn.microsoft.com/api/mcp",
            "tools": ["*"],
        },
    }

    agent = GitHubCopilotAgent(
        default_options={
            "instructions": "You are a helpful assistant with access to the filesystem and Microsoft Learn.",
            "on_permission_request": prompt_permission,
            "mcp_servers": mcp_servers,
        },
    )

    async with agent:
        result = await agent.run("Search Microsoft Learn for 'Azure Functions' and summarize the top result")
        print(result)

De agent gebruiken

De agent is een standaard BaseAgent en ondersteunt alle standaardagentbewerkingen.

Voor meer informatie over hoe je agents uitvoert en ermee werkt, raadpleeg de Aan de slag met agent-tutorials.

Volgende stappen

Aangepaste agents

  • Last updated on