Standardsetup (gebündelte CLI)

Das Python SDK empfiehlt nach der Installation einen einmaligen Downloadschritt:

python -m copilot download-runtime

Dadurch wird die passende Laufzeit heruntergeladen und lokal zwischengespeichert. Wenn Sie diesen Schritt überspringen, versucht das SDK, es automatisch bei der ersten Verwendung als Fallback herunterzuladen.

Am besten geeignet für: Die meisten Anwendungen – Desktop-Apps, eigenständige Tools, CLI-Dienstprogramme, Prototypen und vieles mehr.

So funktioniert es

Wenn Sie das SDK installieren, ist die Copilot-Laufzeit automatisch enthalten (Node.js, .NET) oder wird über python -m copilot download-runtime heruntergeladen (Python). Das SDK startet es als untergeordneter Prozess und kommuniziert über Stdio. Es gibt nichts Zusätzliches zu konfigurieren.

Wichtige Merkmale:

• CLI-Binärdatei ist im SDK enthalten – keine separate Installation erforderlich
• Das SDK verwaltet die CLI-Version, um die Kompatibilität sicherzustellen.
• Benutzer authentifizieren sich über Ihre App (oder verwenden Sie env vars / BYOK)
• Sitzungen werden pro Benutzer auf ihrem Computer verwaltet.

Schnellstart

import { CopilotClient } from "@github/copilot-sdk";

const client = new CopilotClient();

const session = await client.createSession({ model: "gpt-4.1" });
const response = await session.sendAndWait({ prompt: "Hello!" });
console.log(response?.data.content);

await client.stop();

from copilot import CopilotClient
from copilot.session import PermissionHandler

client = CopilotClient()
await client.start()

session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="gpt-4.1")
response = await session.send_and_wait("Hello!")
print(response.data.content)

await client.stop()

package main

import (
    "context"
    "fmt"
    "log"
    copilot "github.com/github/copilot-sdk/go"
)

func main() {
    ctx := context.Background()

    client := copilot.NewClient(nil)
    if err := client.Start(ctx); err != nil {
        log.Fatal(err)
    }
    defer client.Stop()

    session, _ := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-4.1"})
    response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})
    if d, ok := response.Data.(*copilot.AssistantMessageData); ok {
        fmt.Println(d.Content)
    }
}

client := copilot.NewClient(nil)
if err := client.Start(ctx); err != nil {
    log.Fatal(err)
}
defer client.Stop()

session, _ := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-4.1"})
response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})
if d, ok := response.Data.(*copilot.AssistantMessageData); ok {
    fmt.Println(d.Content)
}

await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(
    new SessionConfig { Model = "gpt-4.1" });

var response = await session.SendAndWaitAsync(
    new MessageOptions { Prompt = "Hello!" });
Console.WriteLine(response?.Data.Content);

import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;

var client = new CopilotClient(new CopilotClientOptions()
    // Point to the CLI binary installed on the system
    .setCliPath("/path/to/vendor/copilot")
);
client.start().get();

var session = client.createSession(new SessionConfig()
    .setModel("gpt-4.1")
    .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();

var response = session.sendAndWait(new MessageOptions()
    .setPrompt("Hello!")).get();
System.out.println(response.getData().content());

client.stop().get();

Authentifizierungsstrategien

Sie müssen entscheiden, wie Sich Ihre Benutzer authentifizieren. Hier sind die allgemeinen Muster:

Option A: Anmeldeinformationen des Benutzers (am einfachsten)

Der Benutzer meldet sich einmal bei der CLI an, und Ihre App verwendet diese Anmeldeinformationen. Kein zusätzlicher Code erforderlich – dies ist das Standardverhalten.

const client = new CopilotClient();
// Default: uses signed-in user credentials

Option B: Token über Umgebungsvariable

Senden Sie Ihre App mit Anweisungen zum Festlegen eines Tokens, oder legen Sie sie programmgesteuert fest:

const client = new CopilotClient({
    env: {
        COPILOT_GITHUB_TOKEN: getUserToken(),  // Your app provides the token
    },
});

Option C: BYOK (keine GitHub Authentifizierung erforderlich)

Wenn Sie Ihre eigenen Modellanbieterschlüssel verwalten, benötigen Benutzer überhaupt keine GitHub Konten:

const client = new CopilotClient();

const session = await client.createSession({
    model: "gpt-4.1",
    provider: {
        type: "openai",
        baseUrl: "https://api.openai.com/v1",
        apiKey: process.env.OPENAI_API_KEY,
    },
});

Ausführliche Informationen finden Sie im BYOK (Bring Your Own Key) .

Sitzungsverwaltung

Apps möchten in der Regel benannte Sitzungen, damit Benutzer Unterhaltungen fortsetzen können:

const client = new CopilotClient();

// Create a session tied to the user's project
const sessionId = `project-${projectName}`;
const session = await client.createSession({
    sessionId,
    model: "gpt-4.1",
});

// User closes app...
// Later, resume where they left off
const resumed = await client.resumeSession(sessionId);

Der Sitzungszustand bleibt bei ~/.copilot/session-state/{sessionId}/.

Wann muss ich fortfahren?

Nächste Schritte

• BYOK (Bring Your Own Key): Eigene Schlüssel des Modellanbieters verwenden
• Wiederaufnahme und Persistenz der Sitzung: Erweiterte Sitzungsverwaltung
• Erstellen Sie Ihre erste Copilot-gestützte App: Erstellen einer vollständigen App