GitHub Copilot

Microsoft Agent Framework har stöd för att skapa agenter som använder GitHub Copilot SDK som serverdel. GitHub Copilot-agenter ger åtkomst till kraftfulla kodningsorienterade AI-funktioner, inklusive körning av gränssnittskommandon, filåtgärder, URL-hämtning och MCP-serverintegrering (Model Context Protocol).

Important

GitHub Copilot-agenter kräver en autentiserad GitHub Copilot-körningsmiljö. Vissa SDK:er använder ett installerat CLI, medan Go SDK använder den paketerade körningen som standard. För säkerhet rekommenderar vi att du kör agenter med gränssnitts- eller filbehörigheter i en containerbaserad miljö (Docker/Dev Container).

Getting Started

Lägg till nödvändiga NuGet-paket i projektet.

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

Skapa en GitHub Copilot-agent

Som ett första steg skapar du en CopilotClient och startar den. Använd AsAIAgent sedan tilläggsmetoden för att skapa en agent.

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

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

AIAgent agent = copilotClient.AsAIAgent(sessionConfig: null);

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

Med verktyg och instruktioner

Du kan ange funktionsverktyg och anpassade instruktioner när du skapar agenten:

using GitHub.Copilot;
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?"));

Agentfunktioner

Direktuppspelningssvar

Hämta svar när de genereras:

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

AIAgent agent = copilotClient.AsAIAgent(sessionConfig: null);

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

Console.WriteLine();

Sessionshantering

Underhålla konversationskontext över flera interaktioner med hjälp av sessioner:

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

Som standard kan agenten inte köra gränssnittskommandon, läsa/skriva filer eller hämta URL:er. Om du vill aktivera dessa funktioner anger du en behörighetshanterare via SessionConfig:

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

    string? input = Console.ReadLine()?.Trim().ToUpperInvariant();
    PermissionDecision decision = input is "Y" or "YES"
        ? PermissionDecision.ApproveOnce()
        : PermissionDecision.Reject();

    return Task.FromResult(decision);
}

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"));

Godkännande av verktyg

Eftersom GitHub Copilot SDK äger verktygsanropsloopen framtvingas godkännande för anpassade funktionsverktyg via SDK:s interna förkörningskrok i stället för standardbegäran för Agent Framework-godkännande. När du registrerar ett verktyg omslutet i ApprovalRequiredAIFunctioninstallerar agenten en standardkrok OnPreToolUse som returneras "ask" för verktyget och dirigerar beslutet till OnPermissionRequest hanteraren:

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

AIFunction deleteFile = AIFunctionFactory.Create(
    (string path) => $"Deleted {path}.",
    "DeleteFile",
    "Deletes a file.");

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

SessionConfig sessionConfig = new()
{
    // Wrapping the tool marks it approval-required; the agent turns this into an "ask" at OnPreToolUse.
    Tools = [new ApprovalRequiredAIFunction(deleteFile)],

    // OnPermissionRequest decides the "asked" tools (and Copilot's built-in shell/file/URL prompts).
    OnPermissionRequest = PromptPermission,
};

AIAgent agent = copilotClient.AsAIAgent(sessionConfig);

Console.WriteLine(await agent.RunAsync("Delete the file temp.txt"));

Varning

Om du anger din egen OnPreToolUse krok via SessionConfig.Hookshar den företräde och agenten installerar inte sin standardgodkännandekrok. Du är sedan fullt ansvarig för att framtvinga godkännande för alla ApprovalRequiredAIFunction du registrerar (till exempel genom att returnera ett "deny" eller "ask" ett beslut). Agenten loggar en varning som namnger alla verktyg som krävs för godkännande som din krok måste hantera.

MCP-servrar

Anslut till lokala (stdio) eller fjärranslutna (HTTP) MCP-servrar för utökade funktioner:

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

SessionConfig sessionConfig = new()
{
    OnPermissionRequest = PromptPermission,
    McpServers = new Dictionary<string, McpServerConfig>
    {
        // Local stdio server
        ["filesystem"] = new McpStdioServerConfig
        {
            Command = "npx",
            Args = ["-y", "@modelcontextprotocol/server-filesystem", "."],
            Tools = ["*"],
        },
        // Remote HTTP server
        ["microsoft-learn"] = new McpHttpServerConfig
        {
            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"));

Tips/Råd

Se .NET-exemplen för fullständiga körbara exempel.

Tools

Verktyg	Status	Notes
Funktionsverktyg	✅	Standard-`AIFunction`instanser.
Godkännande av verktyg	✅	Tillhandahålls av ramverkets funktionsanropande chattklient; fungerar med valfritt funktionsverktygsanrop.
Kodtolkare	❌	Inte en Copilot CLI-funktion.
Filsökning	❌	Inte en Copilot CLI-funktion.
Webbsökning	❌	Visas inte som ett värdbaserat verktyg.
Shell/filsystem/URL-hämtning	✅	Inbyggd i Copilot CLI:s körtid och styrd av hanteraren Permissions som du tillhandahåller.
Värdhanterade MCP-verktyg	✅	Fjärranslutna MCP-servrar (HTTP) konfigurerade via `SessionConfig.McpServers`. Se MCP-servrar.
Lokala MCP-verktyg	✅	Lokala (stdio) MCP-servrar som konfigurerats via `SessionConfig.McpServers`. Se MCP-servrar.

Använda agenten

Agenten är en standard AIAgent och stöder alla standard åtgärder AIAgent.

Mer information om hur du kör och interagerar med agenter finns i självstudierna om att komma igång med agenten.

Förutsättningar

Installera GitHub Copilot-paketet för Microsoft Agent Framework.

pip install agent-framework-github-copilot

Configuration

Agenten kan konfigureras med hjälp av följande miljövariabler:

Variabel	Description
`GITHUB_COPILOT_CLI_PATH`	Sökväg till körbar Copilot CLI
`GITHUB_COPILOT_MODEL`	Modell som ska användas (t.ex. `gpt-5`, `claude-sonnet-4`)
`GITHUB_COPILOT_TIMEOUT`	Tidsgräns för begäran i sekunder
`GITHUB_COPILOT_LOG_LEVEL`	CLI-loggnivå
`GITHUB_COPILOT_BASE_DIRECTORY`	Katalog för CLI-sessionstillstånd och konfiguration (standardvärdet `~/.copilot`är )

Getting Started

Importera de klasser som krävs från Agent Framework:

import asyncio
from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions

Skapa en GitHub Copilot-agent

Skapande av grundläggande agent

Det enklaste sättet att skapa en GitHub Copilot-agent:

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

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

Med uttalad konfiguration

Du kan ange en explicit konfiguration via default_options:

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

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

Tips/Råd

default_options(och per körning options) vidarebefordrar alla parametrar som accepteras av Copilot SDK: er create_session , till exempel reasoning_effort, context_tier, enable_citationsprovider (bring-your-own-key), eller skill_directories – inte bara nycklarna som visas här. Okända parameternamn skapar en TypeError, så stavfel fångas i stället för att ignoreras tyst.

Ta med din egen nyckel (BYOK)

Använd Copilot SDK:s BYOK-stöd för att dirigera modellbegäranden via din egen OpenAI-, Azure OpenAI-, Anthropic- eller OpenAI-kompatibla slutpunkt i stället för GitHub Copilot serverdel. Skicka en ProviderConfig genom GitHubCopilotOptions(provider=...)och ange samma modellidentifierare i både providerkonfigurationen och alternativet på sessionsnivå model .

Det körbara exemplet använder följande miljövariabler:

Variabel	Description
`BYOK_PROVIDER_TYPE`	Providertyp: `openai`, `azure`eller `anthropic`. Standardinställningen är `openai`.
`BYOK_BASE_URL`	Bas-URL för providerslutpunkten.
`BYOK_API_KEY`	Statisk API-nyckel för providerslutpunkten.
`BYOK_MODEL_ID`	Modellidentifierare som ska begäras. Standardinställningen är `gpt-4o`.

Varning

BYOK använder statiska autentiseringsuppgifter och tillhandahåller inte automatisk tokenuppdatering. Håll API-nycklar borta från källkontrollen och läs in dem från miljövariabler eller ett hemligt arkiv. Användning och fakturering spåras av din leverantör i stället för GitHub.

import asyncio
import os
from typing import Literal, cast

from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions
from copilot.session import ProviderConfig


async def main() -> None:
    print("=== GitHub Copilot Agent with BYOK (Bring Your Own Key) ===\n")

    model_id = os.environ.get("BYOK_MODEL_ID", "gpt-4o")
    provider_type = cast(Literal["openai", "azure", "anthropic"], os.environ.get("BYOK_PROVIDER_TYPE", "openai"))

    # ProviderConfig routes the session through a custom endpoint instead of the GitHub
    # Copilot backend. `wire_api="completions"` is the broadly compatible choice; use
    # "responses" for providers that support the OpenAI Responses API.
    provider: ProviderConfig = {
        "type": provider_type,
        "base_url": os.environ["BYOK_BASE_URL"],
        "api_key": os.environ["BYOK_API_KEY"],
        "wire_api": "completions",
        "model_id": model_id,
    }

    # BYOK requires the model to also be set at the session level.
    agent: GitHubCopilotAgent[GitHubCopilotOptions] = GitHubCopilotAgent(
        instructions="You are a helpful assistant.",
        default_options=GitHubCopilotOptions(model=model_id, provider=provider),
    )

    async with agent:
        query = "What are the benefits of using your own API keys with an agent framework?"
        print(f"User: {query}")
        result = await agent.run(query)
        print(f"\nAgent: {result}\n")

Agentfunktioner

Kontextprovidrar

Python GitHubCopilotAgent stöder context_providers=[...]också . Leverantörer kör före och efter varje anrop, så provider-tillagda meddelanden och instruktioner ingår i Copilot-prompten och historikprovidrar kan observera det slutliga svaret.

from agent_framework import InMemoryHistoryProvider

agent = GitHubCopilotAgent(
    instructions="You are a helpful coding assistant.",
    context_providers=[InMemoryHistoryProvider()],
)

Du kan kombinera inbyggda historikprovidrar med anpassade kontextprovidrar. Information om implementeringsmönster finns i Kontextprovidrar.

Funktionsverktyg

Utrusta din agent med anpassade funktioner:

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(
        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)

Direktuppspelningssvar

Få svar när de genereras för bättre användarupplevelse:

async def streaming_example():
    agent = GitHubCopilotAgent(
        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()

Trådhantering

Underhålla konversationskontext över flera interaktioner:

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

    async with agent:
        session = agent.create_session()

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

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

Permissions

Som standard kan agenten inte köra gränssnittskommandon, läsa/skriva filer eller hämta URL:er. Om du vill aktivera de här funktionerna anger du en behörighetshanterare:

import asyncio

from copilot.generated.rpc import PermissionDecisionDeniedInteractivelyByUser
from copilot.session import PermissionHandler, PermissionRequestResult
from copilot.session_events import PermissionRequest


async def prompt_permission(
    request: PermissionRequest, context: dict[str, str]
) -> PermissionRequestResult:
    print(f"\n[Permission Request: {request.kind}]")
    response = (await asyncio.to_thread(input, "Approve? (y/n): ")).strip().lower()
    if response in ("y", "yes"):
        return PermissionHandler.approve_all(request, context)
    return PermissionDecisionDeniedInteractivelyByUser()

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

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

För betrodda miljöer där alla behörigheter ska godkännas automatiskt använder du den inbyggda PermissionHandler.approve_all:

from copilot.session import PermissionHandler

agent = GitHubCopilotAgent(
    default_options={
        "on_permission_request": PermissionHandler.approve_all,
    },
)

Behörighetshanterare stöder både synkronisering och asynkrona återanrop. Använd asyncio.to_thread för interaktiva frågor i asynkrona hanterare för att undvika att blockera händelseloopen.

Godkännande av verktyg

Eftersom GitHub Copilot SDK äger verktygsanropsloopen framtvingas godkännande för anpassade funktionsverktyg via SDK:s interna förkörningskrok i stället för standardbegäran för Agent Framework-godkännande. När du registrerar ett verktyg som deklarerats med approval_mode="always_require" och inte anger en egen on_pre_tool_use krok installerar agenten en standardkrok som returnerar "ask" för verktyget och dirigerar beslutet till din on_permission_request hanterare:

from agent_framework import tool
from agent_framework.github import GitHubCopilotAgent, GitHubCopilotOptions
from copilot.session import PermissionHandler


@tool(approval_mode="always_require")
def delete_file(path: str) -> str:
    """Delete a file."""
    return f"Deleted {path}."


agent = GitHubCopilotAgent(
    tools=[delete_file],
    # The "ask" decision is routed here; approve or deny the call.
    default_options=GitHubCopilotOptions(on_permission_request=PermissionHandler.approve_all),
)

Varning

Om du anger din egen on_pre_tool_use krok har den företräde och agenten installerar inte sin standardgodkännandekrok. Du är sedan fullt ansvarig för att framtvinga godkännande för alla approval_mode="always_require" verktyg (till exempel genom att returnera ett "deny" eller "ask" ett beslut). Agenten loggar en varning som namnger alla verktyg som krävs för godkännande som din krok måste hantera. Med standardbehörighetshanteraren neka alla nekas ett always_require verktyg om du inte kopplar en godkännande on_permission_request.

MCP-servrar

Anslut till lokala (stdio) eller fjärranslutna (HTTP) MCP-servrar för utökade funktioner:

from copilot.session import MCPServerConfig, PermissionHandler

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(
        instructions="You are a helpful assistant with access to the filesystem and Microsoft Learn.",
        default_options={
            "on_permission_request": PermissionHandler.approve_all,
            "mcp_servers": mcp_servers,
        },
    )

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

Observability

GitHubCopilotAgent har inbyggd OpenTelemetry-spårning. Anropa configure_otel_providers() en gång vid start för att aktivera intervall, mått och loggar för varje körning:

from agent_framework.observability import configure_otel_providers
from agent_framework.github import GitHubCopilotAgent

configure_otel_providers(enable_console_exporters=True)

async with GitHubCopilotAgent() as agent:
    response = await agent.run("Hello!")

Om du behöver den underliggande agenten utan telemetrilagret (till exempel omsluta den i en anpassad) importerar du RawGitHubCopilotAgent från agent_framework.github.

Information om OTLP-exportörer och mer omfattande exempel finns i observerbarhetsexemplen.

Tools

Verktyg	Status	Notes
Funktionsverktyg	✅	Vanliga anropsbara Python-objekt eller `@ai_function`.
Godkännande av verktyg	✅	Tillhandahålls av ramverkets funktionsanropande chattklient; fungerar med valfritt funktionsverktygsanrop.
Kodtolkare	❌	Inte en Copilot CLI-funktion.
Filsökning	❌	Inte en Copilot CLI-funktion.
Webbsökning	❌	Visas inte som ett värdbaserat verktyg.
Shell/filsystem/URL-hämtning	✅	Inbyggd i Copilot CLI-körmiljön och styrd av hanteraren Permissions som du tillhandahåller.
Värdhanterade MCP-verktyg	✅	Fjärranslutna MCP-servrar (HTTP) konfigurerade via `default_options["mcp_servers"]`. Se MCP-servrar.
Lokala MCP-verktyg	✅	Lokala (stdio) MCP-servrar som konfigurerats via `default_options["mcp_servers"]`. Se MCP-servrar.

Använda agenten

Agenten är en standard BaseAgent och stöder alla standardagentåtgärder.

Mer information om hur du kör och interagerar med agenter finns i självstudierna om att komma igång med agenten.

Getting Started

Installera modulen Microsoft Agent Framework Go och GitHub Copilot SDK för Go. Agent Framework Go SDK kräver Go 1.25 eller senare.

go get github.com/microsoft/agent-framework-go github.com/github/copilot-sdk/go

Skapa en GitHub Copilot-agent

Skapa och starta en copilot.Clientoch skicka den sedan till copilotprovider.NewAgent.

import (
    "context"
    "fmt"

    copilot "github.com/github/copilot-sdk/go"
    "github.com/microsoft/agent-framework-go/provider/copilotprovider"
)

ctx := context.Background()

copilotClient := copilot.NewClient(nil)
if err := copilotClient.Start(ctx); err != nil {
    panic(err)
}
defer func() { _ = copilotClient.Stop() }()

copilotAgent := copilotprovider.NewAgent(
    copilotClient,
    copilotprovider.AgentConfig{
        Instructions: "You are a helpful assistant.",
    },
)

response, err := copilotAgent.RunText(ctx, "What is Microsoft Agent Framework?").Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

Med verktyg och instruktioner

Du kan ange funktionsverktyg och anpassade instruktioner när du skapar agenten:

import (
    "context"
    "fmt"

    copilot "github.com/github/copilot-sdk/go"
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/provider/copilotprovider"
    "github.com/microsoft/agent-framework-go/tool"
    "github.com/microsoft/agent-framework-go/tool/functool"
)

weatherTool := functool.MustNew(
    functool.Config{
        Name:        "GetWeather",
        Description: "Get the weather for a given location.",
    },
    func(_ context.Context, location string) (string, error) {
        return fmt.Sprintf("The weather in %s is sunny with a high of 25C.", location), nil
    },
)

copilotAgent := copilotprovider.NewAgent(
    copilotClient,
    copilotprovider.AgentConfig{
        Instructions: "You are a helpful weather agent.",
        Config: agent.Config{
            Tools: []tool.Tool{weatherTool},
        },
    },
)

response, err := copilotAgent.RunText(ctx, "What's the weather like in Seattle?").Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

Agentfunktioner

Direktuppspelningssvar

Hämta svar när de genereras:

for update, err := range copilotAgent.RunText(ctx, "Tell me a short story.", agent.Stream(true)) {
    if err != nil {
        panic(err)
    }
    fmt.Print(update)
}

fmt.Println()

Sessionshantering

Underhålla konversationskontext över flera interaktioner med hjälp av sessioner:

session, err := copilotAgent.CreateSession(ctx)
if err != nil {
    panic(err)
}

// First turn
response, err := copilotAgent.RunText(ctx, "My name is Alice.", agent.WithSession(session)).Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

// Second turn - the agent remembers the context
response, err = copilotAgent.RunText(ctx, "What is my name?", agent.WithSession(session)).Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

Permissions

Som standard kan agenten inte köra gränssnittskommandon, läsa/skriva filer eller hämta URL:er. Om du vill aktivera dessa funktioner anger du en behörighetshanterare via copilot.SessionConfig:

import (
    "bufio"
    "fmt"
    "os"
    "strings"

    copilot "github.com/github/copilot-sdk/go"
    "github.com/github/copilot-sdk/go/rpc"
    "github.com/microsoft/agent-framework-go/provider/copilotprovider"
)

func promptPermission(request copilot.PermissionRequest, _ copilot.PermissionInvocation) (rpc.PermissionDecision, error) {
    fmt.Printf("\n[Permission Request: %s]\n", request.Kind())
    fmt.Print("Approve? (y/n): ")

    input, _ := bufio.NewReader(os.Stdin).ReadString('\n')
    input = strings.TrimSpace(strings.ToUpper(input))
    if input == "Y" || input == "YES" {
        return &rpc.PermissionDecisionApproveOnce{}, nil
    }
    return &rpc.PermissionDecisionReject{}, nil
}

copilotAgent := copilotprovider.NewAgent(
    copilotClient,
    copilotprovider.AgentConfig{
        SessionConfig: &copilot.SessionConfig{
            OnPermissionRequest: promptPermission,
        },
    },
)

response, err := copilotAgent.RunText(ctx, "List all files in the current directory").Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

MCP-servrar

Anslut till lokala (stdio) eller fjärranslutna (HTTP) MCP-servrar för utökade funktioner:

import (
    copilot "github.com/github/copilot-sdk/go"
    "github.com/microsoft/agent-framework-go/provider/copilotprovider"
)

mcpServers := map[string]copilot.MCPServerConfig{
    // Local stdio server
    "filesystem": copilot.MCPStdioServerConfig{
        Command: "npx",
        Args:    []string{"-y", "@modelcontextprotocol/server-filesystem", "."},
        Tools:   []string{"*"},
    },
    // Remote HTTP server
    "microsoft-learn": copilot.MCPHTTPServerConfig{
        URL:   "https://learn.microsoft.com/api/mcp",
        Tools: []string{"*"},
    },
}

copilotAgent := copilotprovider.NewAgent(
    copilotClient,
    copilotprovider.AgentConfig{
        Instructions: "You are a helpful assistant with access to the filesystem and Microsoft Learn.",
        SessionConfig: &copilot.SessionConfig{
            OnPermissionRequest: promptPermission,
            MCPServers:          mcpServers,
        },
    },
)

response, err := copilotAgent.RunText(ctx, "Search Microsoft Learn for 'Azure Functions' and summarize the top result").Collect()
if err != nil {
    panic(err)
}
fmt.Println(response)

Tips/Råd

Ett fullständigt körbart exempel finns i Go GitHub Copilot-exemplet.

Tools

Verktyg	Status	Notes
Funktionsverktyg	✅	Standardinstanser för Go `tool.Tool`, inklusive `functool` funktioner.
Godkännande av verktyg	✅	Funktionsverktyg kan använda standardstödet för godkännande av Go-verktyg; Copilots körningsbehörigheter hanteras av `SessionConfig.OnPermissionRequest`.
Kodtolkare	❌	Inte en Copilot CLI-funktion.
Filsökning	❌	Inte en Copilot CLI-funktion.
Webbsökning	❌	Visas inte som ett värdbaserat verktyg.
Shell/filsystem/URL-hämtning	✅	Inbyggd i Copilot CLI-körmiljön och styrd av hanteraren Permissions som du tillhandahåller.
Värdhanterade MCP-verktyg	✅	Fjärranslutna MCP-servrar (HTTP) konfigurerade via `copilot.SessionConfig.MCPServers`. Se MCP-servrar.
Lokala MCP-verktyg	✅	Lokala (stdio) MCP-servrar som konfigurerats via `copilot.SessionConfig.MCPServers`. Se MCP-servrar.

Använda agenten

Agenten är en standard *agent.Agent och stöder alla standardagentåtgärder.

Mer information om hur du kör och interagerar med agenter finns i självstudierna om att komma igång med agenten.

Nästa steg

Copilot Studio

Feedback

Var den här sidan till hjälp?

Last updated on 2026-08-13

GitHub Copilot

Getting Started

Skapa en GitHub Copilot-agent

Med verktyg och instruktioner

Agentfunktioner

Direktuppspelningssvar

Sessionshantering

Permissions

Godkännande av verktyg

MCP-servrar

Tools

Använda agenten

Förutsättningar

Configuration

Getting Started

Skapa en GitHub Copilot-agent

Skapande av grundläggande agent

Med uttalad konfiguration

Ta med din egen nyckel (BYOK)

Agentfunktioner

Kontextprovidrar

Funktionsverktyg

Direktuppspelningssvar

Trådhantering

Permissions

Godkännande av verktyg

MCP-servrar

Observability

Tools

Använda agenten

Getting Started

Skapa en GitHub Copilot-agent

Med verktyg och instruktioner

Agentfunktioner

Direktuppspelningssvar

Sessionshantering

Permissions

MCP-servrar

Tools

Använda agenten

Nästa steg

Feedback

Ytterligare resurser