Einheitliche Integration von GPT, Claude und anderen KI-Modellen mit Copilot CLI

06.05.2026

Einheitliche Integration von GPT, Claude und anderen KI-Modellen mit Copilot CLI

In der KI-Anwendungsentwicklung: Wie kann man eine einheitliche Schnittstelle für verschiedene Modelle wie GPT und Claude erstellen? Dieser Artikel teilt das Design eines KI-Anbietersystems auf Basis der Orleans Grain-Architektur sowie praktische Erfahrungen mit der Integration von GitHub Copilot CLI.

Hintergrund

In der modernen KI-Anwendungsentwicklung ist die Integration der neuesten GPT-Modelle ein Kernbedürfnis vieler Entwickler. GitHub Copilot CLI ist ein leistungsstarkes Tool, das nicht nur die GPT-Serie von OpenAI (wie GPT-4, GPT-5) unterstützt, sondern auch andere gängige KI-Modelle wie Claude. Mit Copilot CLI können Entwickler verschiedene KI-Modelle über eine einheitliche Befehlszeilenschnittstelle aufrufen, ohne für jedes Modell komplexe Integrationslogik separat implementieren zu müssen.

Dies ist im Grunde ein altes bekanntes Problem. Für jedes Modell die Aufruflogik einmal zu schreiben – darüber viel zu sprechen, bringt nur Tränen. Schließlich wird jeder irgendwann nervös, wenn er zu viel Code schreibt. Statt das Rad neu zu erfinden, ist es besser, eine einheitliche Schnittstelle zu finden, die alles erledigt. Copilot CLI ist genau so etwas – du rufst einfach auf, den Rest übernimmt es.

Kernwerte:

Einheitliche CLI-Schnittstelle für den Zugriff auf verschiedene KI-Modelle
Unterstützung für Sitzungsverwaltung und Kontextbeibehaltung
Integrierte Tool-Aufruffunktionen (Dateioperationen, Git-Operationen usw.)
Unterstützung für Streaming-Antworten und Echtzeitausgabe

Über HagiCode

Das in diesem Artikel vorgestellte Konzept stammt aus unseren praktischen Erfahrungen im HagiCode-Projekt. HagiCode ist ein KI-Codierassistent-Projekt. Bei der Entwicklung sind wir auf die Herausforderung gestoßen, gleichzeitig mehrere KI-Modelle unterstützen zu müssen – manche Benutzer sind an GPT-4 gewöhnt, andere bevorzugen Claude, und einige wollen das neueste GPT-5 ausprobieren. Wenn man für jedes Modell eine eigene Aufruflogik implementiert, wird der Code schwer zu warten. Durch die einheitliche Schnittstelle von Copilot CLI haben wir dieses Problem der Unterstützung mehrerer Modelle erfolgreich gelöst.

Offen gesagt haben die Benutzer einfach unterschiedliche Vorlieben – schwer, allen gerecht zu werden. Manche mögen GPT, andere bevorzugen Claude, und einige bestehen darauf, das neueste GPT-5 zu verwenden. Wir wollten nur, dass jeder sein bevorzugtes Modell nutzen kann – schließlich ist Zufriedenheit am wichtigsten.

Systemarchitektur-Design

Wir haben ein erweiterbares KI-Anbietersystem auf Basis der Orleans Grain-Architektur implementiert. Die Gesamtarchitektur sieht wie folgt aus:

┌─────────────────┐
│  Frontend/Client │
└────────┬────────┘
         │
         ▼
┌─────────────────────────────────┐
│  IGitHubCopilotGrain (Schnittstelle)   │
│  - ExecuteCommandStreamAsync    │
│  - RunEditAsync                 │
│  - CancelAsync                  │
└────────┬────────────────────────┘
         │
         ▼
┌─────────────────────────────────┐
│  GitHubCopilotGrain (Implementierung)    │
│  - Zustandsverwaltung                      │
│  - Sitzungsbindung                      │
│  - Antwortzuordnung                      │
└────────┬────────────────────────┘
         │
         ▼
┌─────────────────────────────────┐
│  CopilotAIProvider (Anbieterschicht)   │
│  - Konfigurationsanalyse                      │
│  - Rechteverwaltung                      │
│  - Streaming-Verarbeitung                      │
└────────┬────────────────────────┘
         │
         ▼
┌─────────────────────────────────┐
│  HagiCode.Libs (Shared Runtime)     │
│  - Copilot CLI-Prozessverwaltung          │
│  - Nachrichtenprotokollanalyse                  │
│  - Sitzungsaufrechterhaltung                      │
└─────────────────────────────────┘

Der Vorteil dieser Architektur liegt in klarer Schichtung und einzelner Verantwortung. Die Schnittstellenschicht definiert den einheitlichen KI-Dienstvertrag, die Implementierungsschicht verarbeitet die verteilte Zustandsverwaltung von Orleans, die Anbieterschicht kapselt die Interaktionsdetails von Copilot CLI, und die Laufzeitebene ist für die Kommunikation mit dem CLI-Prozess verantwortlich.

Offen gesagt: Teile die Aufgaben klar auf, jeder tut das, was er tun soll, mische nichts durcheinander. Schließlich ist es bei Code schwierig, etwas zu ändern, wenn es einmal durcheinander ist.

Analyse der Kernkomponenten

1. GitHubCopilotGrain: Verteilte KI-Dienstschnittstelle

Als Orleans Grain-Implementierung bietet GitHubCopilotGrain verteilte KI-Dienstfähigkeiten:

public interface IGitHubCopilotGrain : IGrainWithStringKey
{
    /// <summary>
    /// Führt einen Befehl aus und gibt die Antwort als Stream zurück
    /// </summary>
    Task<IAsyncEnumerable<GitHubCopilotResponse>> ExecuteCommandStreamAsync(
        string command,
        string? heroId = null,
        CancellationToken token = default,
        string? executionMessageId = null,
        string? systemMessage = null,
        Dictionary<string, string>? requestSettings = null);

    /// <summary>
    /// Führt eine Bearbeitungsoperation aus
    /// </summary>
    Task<IAsyncEnumerable<GitHubCopilotResponse>> RunEditAsync(
        string editCommand,
        string? heroId = null,
        CancellationToken token = default);

    /// <summary>
    /// Bricht die aktuelle Ausführung ab
    /// </summary>
    Task CancelAsync(string heroId);
}

Wichtige Designpunkte:

Verwendung von IAsyncEnumerable zur Unterstützung von Streaming-Antworten, Vermeidung langer Wartezeiten
Sitzungsbasierte Zustandsisolierung durch heroId
Unterstützung für die dynamische Konfiguration von Modellparametern durch requestSettings

2. CopilotAIProvider: Kernanbieter-Implementierung

CopilotAIProvider ist der Kern des gesamten Konzepts und kapselt die gesamte Interaktionslogik mit Copilot CLI:

public class CopilotAIProvider : IAIProvider, IVersionedAIProvider
{
    private readonly CopilotOptions _options;
    private readonly ICopilotProcessExecutor _executor;

    public async IAsyncEnumerable<AIStreamingChunk> SendMessageAsync(
        AIRequest request,
        string? embeddedCommandPrompt = null,
        [EnumeratorCancellation] CancellationToken cancellationToken = default)
    {
        // Optionen erstellen
        var options = new CopilotOptions
        {
            Model = request.Model ?? _options.Model,
            SessionId = request.Options?.Settings?.GetValueOrDefault("copilotSessionId"),
            Timeout = _options.Timeout,
            PermissionMode = request.OperationType == AIOperationType.Edit
                ? CopilotPermissionMode.BypassPermissions
                : CopilotPermissionMode.Default
        };

        // Befehl ausführen und Antwort streamen
        await foreach (var message in _executor.ExecuteAsync(
            options, request.Prompt, cancellationToken))
        {
            yield return BuildChunk(message);
        }
    }
}

Kernmerkmale:

Automatischer Wiederholungsmechanismus: Behandelt temporäre Netzwerkprobleme und CLI-Prozessausnahmen
Verfolgung des Inferenzinhalts: Erfasst den Inferenzprozess des Modells (reasoning-Feld)
Verarbeitung verschiedener Nachrichtentypen: Unterstützt assistant-, tool.started-, tool.completed- und andere Nachrichten
Umschaltung der Berechtigungsmodi: Bearbeitungsoperationen verwenden automatisch bypassPermissions, normale Abfragen verwenden default

3. CopilotOptions: Flexibles Konfigurationssystem

Die Konfigurationsklasse unterstützt umfangreiche Optionseinstellungen:

public class CopilotOptions
{
    /// <summary>
    /// Gibt das zu verwendende Modell an, z. B. "gpt-4", "gpt-5", "claude-opus-4.5"
    /// </summary>
    public string Model { get; set; } = "gpt-4";

    /// <summary>
    /// Pfad zur Copilot CLI-Programmdatei
    /// </summary>
    public string ExecutablePath { get; set; } = "copilot";

    /// <summary>
    /// Sitzungszeitüberschreitung
    /// </summary>
    public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1800);

    /// <summary>
    /// Authentifizierungsmethode
    /// </summary>
    public CopilotAuthSource AuthSource { get; set; } = CopilotAuthSource.LoggedInUser;

    /// <summary>
    /// Berechtigungsmodus
    /// </summary>
    public CopilotPermissionMode PermissionMode { get; set; } = CopilotPermissionMode.Default;

    /// <summary>
    /// Sitzungs-ID zur Beibehaltung des Kontexts
    /// </summary>
    public string? SessionId { get; set; }

    /// <summary>
    /// Tool-Berechtigungskonfiguration
    /// </summary>
    public CopilotToolPermissions? Permissions { get; set; }
}

Bei der Konfiguration geht es darum, dass es ausreichend ist. Schließlich möchte niemand eine Menge Konfigurationen schreiben, die man nie benutzt? Die meisten Szenarien abzudecken, reicht aus.

Konfigurationsanleitung

1. Grundkonfiguration

Fügen Sie die Copilot-Anbieterkonfiguration in appsettings.json hinzu:

{
  "AI": {
    "Providers": {
      "Providers": {
        "GitHubCopilot": {
          "Enabled": true,
          "ExecutablePath": "copilot",
          "Model": "gpt-5",
          "Timeout": 1800,
          "IdleTimeout": 300,
          "UseLoggedInUser": true,
          "NoAskUser": true,
          "PermissionMode": "default",
          "Permissions": {
            "AllowAllTools": false,
            "AllowAllPaths": false,
            "AllowedTools": ["Read", "Bash(git:*)", "Bash(cat:*)"],
            "DeniedTools": []
          }
        }
      }
    }
  }
}

2. Modellauswahl

Das System unterstützt die folgenden Modelle (angegeben über den Parameter --model von Copilot CLI):

Modell	Beschreibung	Empfohlene Szenarien
gpt-4 / gpt-4-turbo	OpenAI vierte Generation	Allgemeine Aufgaben, gutes Preis-Leistungs-Verhältnis
gpt-5	OpenAI neueste fünfte Generation	Komplexe Inferenz, beste Ergebnisse erforderlich
claude-sonnet-4.5	Anthropic Sonnet 4.5	Ausgewogene Leistung und Kosten
claude-opus-4.5	Anthropic Opus 4.5	Aufgaben mit hoher Genauigkeit

In der Praxis von HagiCode verwenden wir standardmäßig GPT-4 als tägliches Modell, für komplexe Aufgaben (wie große Refactorings) wechseln wir zu GPT-5, während Claude-Modelle als Alternative für Benutzer angeboten werden, die Anthropic bevorzugen.

3. Dienste registrieren

Registrieren Sie die entsprechenden Dienste im DI-Container:

// Copilot KI-Anbieter registrieren
services.AddSingleton<IAIProvider, CopilotAIProvider>();

// Orleans Grain registrieren
services.AddSingleton<IGitHubCopilotGrain, GitHubCopilotGrain>();

// Prozess-Executor registrieren
services.AddSingleton<ICopilotProcessExecutor, CopilotProcessExecutor>();

Eigentlich sind es nur diese wenigen Zeilen Code, nichts Besonderes. Registriere einfach alles, was registriert werden muss, damit man es findet, wenn man es braucht.

Praxisbeispiele

1. Grundlegender Aufruf

// Grain abrufen
var grain = grainFactory.GetGrain<IGitHubCopilotGrain>("session-123");

// Befehl ausführen
await foreach (var response in grain.ExecuteCommandStreamAsync(
    "Analysiere die Codestruktur des aktuellen Verzeichnisses und generiere Dokumentation",
    heroId: null,
    token: cancellationToken))
{
    switch (response.Type)
    {
        case ExecutorResponseType.Text:
            Console.Write(response.Content);
            break;
        case ExecutorResponseType.ToolCall:
            Console.WriteLine($"[Tool-Aufruf] {response.ToolName}");
            break;
        case ExecutorResponseType.Completion:
            Console.WriteLine($"\n[Fertigstellung] Token-Verwendung: {response.PromptTokens}+{response.CompletionTokens}");
            break;
    }
}

2. Sitzung mit Kontext

var requestSettings = new Dictionary<string, string>
{
    { "model", "gpt-5" },
    { "temperature", "0.7" },
    { "maxTokens", "4096" },
    { "copilotSessionId", "existing-session-123" }  // Sitzungskontext beibehalten
};

await foreach (var response in grain.ExecuteCommandStreamAsync(
    "Basierend auf der vorherigen Analyse, generiere entsprechende Unit-Tests",
    requestSettings: requestSettings,
    token: cancellationToken))
{
    // Antwort verarbeiten
}

3. Bearbeitungsmodus-Aufruf

await foreach (var response in grain.RunEditAsync(
    "Konvertiere alle PascalCase-Benennungen in camelCase",
    heroId: "hero-001",
    token: cancellationToken))
{
    if (response.Type == ExecutorResponseType.FileEdit)
    {
        Console.WriteLine($"[Bearbeitung] {response.FilePath}: {response.EditCount} Änderungen");
    }
}

Best Practices

Sitzungsaufrechterhaltung

Mit dem Parameter copilotSessionId kann der Kontext über Anforderungen hinweg aufrechterhalten werden. Dies ist sehr nützlich in Szenarien, die mehrere Dialogrunden erfordern. Zum Beispiel:

// Erste Runde: Kontext erstellen
var settings1 = new Dictionary<string, string> { { "copilotSessionId", "session-001" } };
await grain.ExecuteCommandStreamAsync("Dies ist ein C#-Projekt, das .NET 8 verwendet", requestSettings: settings1);

// Zweite Runde: Fragen basierend auf Kontext
var settings2 = new Dictionary<string, string> { { "copilotSessionId", "session-001" } };
await grain.ExecuteCommandStreamAsync("Empfehle eine geeignete Projektstruktur", requestSettings: settings2);

Schließlich ist KI nicht allmächtig – ohne Kontext weiß sie nicht, wovon du sprichst? Wie bei einem Gespräch muss man hin und her kommunizieren, um ein Gespräch fortzusetzen.

Berechtigungssteuerung

Wählen Sie je nach Operationstyp den geeigneten Berechtigungsmodus:

Abfrageoperationen: Verwenden Sie den default-Modus, damit die KI nur Dateien lesen und sichere Git-Befehle ausführen kann
Bearbeitungsoperationen: Verwenden Sie den bypassPermissions-Modus, damit die KI Dateien ändern kann

var permissionMode = operationType == AIOperationType.Edit
    ? CopilotPermissionMode.BypassPermissions
    : CopilotPermissionMode.Default;

Tool-Whitelist

Steuern Sie die von der KI ausführbaren Operationen über die AllowedTools-Konfiguration:

{
  "Permissions": {
    "AllowAllTools": false,
    "AllowedTools": [
      "Read",
      "Bash(git:*)",
      "Bash(cat:*)",
      "Glob"
    ]
  }
}

In HagiCode schränken wir die Operationsberechtigungen der KI strikt ein und erlauben nur das Lesen von Dateien und das Ausführen von Git-Befehlen, um die Systemsicherheit zu gewährleisten.

Bei Sicherheit kann man nicht vorsichtig genug sein. Wer weiß, ob die KI auf einmal die Idee bekommt, dein gesamtes Projekt zu löschen?

Timeout-Behandlung

Das Standard-Timeout ist auf 30 Minuten eingestellt. Für Operationen, die viele Dateien betreffen (z. B. vollständige Codeanalyse), muss es möglicherweise angepasst werden:

var options = new CopilotOptions
{
    Timeout = TimeSpan.FromMinutes(60)  // Auf 60 Minuten erweitern
};

Häufige Fragen

F: Wie wechselt man zwischen verschiedenen KI-Modellen?

A: Über den Konfigurationseintrag Model oder requestSettings angeben:

var settings = new Dictionary<string, string> { { "model", "claude-opus-4.5" } };

Eigentlich ist es nur eine Parameteränderung, nichts Komplexes.

F: Wie lange bleibt der Sitzungskontext erhalten?

A: Hängt von der Implementierung von Copilot CLI ab, normalerweise wird er nach dem Sitzungs-Idle-Timeout (standardmäßig 5 Minuten) bereinigt. Kann über die IdleTimeout-Konfiguration angepasst werden.

F: Wie geht man mit Abstürzen des CLI-Prozesses um?

A: CopilotAIProvider hat einen integrierten automatischen Wiederholungsmechanismus, der Prozessausnahmen abfängt und den CLI neu startet. Wenn die Anzahl der aufeinanderfolgenden Fehler zu hoch ist, wird eine AIProviderException ausgelöst.

Programmabstürze lassen sich nicht vermeiden. Man kann nur bestmögliche Fehlertoleranz versuchen – wenn es wirklich abstürzt, starte einfach neu.

F: Werden benutzerdefinierte Tools unterstützt?

A: Die von Copilot CLI unterstützten Tools sind vordefiniert, aber über die AllowedTools-Konfiguration kann gesteuert werden, welche Tools verfügbar sind. Benutzerdefinierte Tools müssen auf zukünftige Updates von Copilot CLI warten.

Zusammenfassung

Durch die einheitliche Integration mehrerer KI-Modelle mit Copilot CLI haben wir das Problem der Unterstützung mehrerer Modelle in der HagiCode-Entwicklung gelöst. Die Kernvorteile dieses Konzepts liegen in:

Einheitliche Schnittstelle: Ein Code unterstützt mehrere Modelle wie GPT, Claude usw.
Sitzungsverwaltung: Automatische Behandlung der Kontextbeibehaltung und Sitzungsisolierung
Tool-Integration: Integrierte häufig verwendete Tools wie Dateioperationen, Git-Operationen usw.
Streaming-Antworten: Echtzeit-Rückgabe der KI-Ausgabe, verbessert die Benutzererfahrung
Sicherheit und Kontrolle: Granulare Berechtigungssteuerung und Tool-Whitelist

Wenn Ihr Projekt auch mehrere KI-Modelle unterstützen muss oder Sie nach einer ausgereiften CLI-Tool-Integrationslösung suchen, probieren Sie unbedingt Copilot CLI aus. Diese Architektur wurde in HagiCode umfassend validiert und kann die komplexen Anforderungen von Produktionsumgebungen bewältigen.

Schließlich will niemand für jedes Modell einen Satz Aufrufcode schreiben? Mit einer einheitlichen Lösung sind alle entspannt.

Referenzmaterial

Wenn dir dieser Artikel hilft:

Komm zu GitHub und gib einen Star: github.com/HagiCode-org/site
Besuche die Website für mehr Informationen: hagicode.com
Schau dir das Demovideo der offiziellen Version an: www.bilibili.com/video/BV1z4oWB3EpY/
Ein-Klick-Installation und Test: docs.hagicode.com/installation/docker-compose
Desktop-Ende Schnellinstallation: hagicode.com/desktop/
Die öffentliche Beta hat begonnen, herzlich willkommen zur Installation und zum Test

开始使用 HagiCode

一次安装，几分钟上手

HagiCode for Windows 在 Microsoft Store 免费提供。打开商店即可安装并保持更新；也可以先对比各版本与定价，再决定从哪个渠道开始。

前往 Microsoft Store 安装查看版本与定价