> ## Documentation Index
> Fetch the complete documentation index at: https://apidoc.cometapi.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Pi mit CometAPI verwenden

> Verwenden Sie diese Anleitung, um Pi mit CometAPI zu konfigurieren, indem Sie die base URL, den API key sowie model- oder provider-Optionen festlegen.

[Pi](https://github.com/earendil-works/pi) ist das Projekt Pi Agent Harness. Das Paket `@earendil-works/pi-coding-agent` stellt eine interaktive Coding-Agent-CLI mit Workflows für Dateien, Shell, Bearbeiten, Schreiben, Sitzungen, Ausgabe, JSON, RPC und SDK bereit. Pi kann benutzerdefinierte provider aus `~/.pi/agent/models.json` laden, sodass Sie CometAPI als OpenAI-kompatible provider-Einträge hinzufügen können, ohne den Pi-Quellcode zu ändern.

Offizielle Referenzen:

* [Pi-Repository](https://github.com/earendil-works/pi)
* [Pi-Schnellstart](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/quickstart.md)
* [Pi-provider](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/providers.md)
* [Pi-benutzerdefinierte Modelle](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)
* [Verwendung der Pi-CLI](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/usage.md)

<Note>
  Die Verfügbarkeit von Modellen ändert sich im Laufe der Zeit. Ersetzen Sie `your-model-id` durch eine verfügbare model ID von der [CometAPI-Modelle-Seite](/de/overview/models).
</Note>

## Voraussetzungen

* Node.js `>=22.19.0`
* npm
* Ein CometAPI-Konto mit einem aktiven API key aus dem [Dashboard](https://www.cometapi.com/console/token)
* Pi, installiert aus dem offiziellen npm-Paket

## Laufzeitberechtigungen verstehen

Pi wird mit den Berechtigungen des Benutzers und Prozesses ausgeführt, der es startet. Starten Sie Pi im Projektverzeichnis, in dem es arbeiten soll, behalten Sie einen Rollback-Pfad wie git bei, und verwenden Sie einen Container oder eine Sandbox, wenn Sie stärkere Grenzen für Dateisystem, Prozesse, Netzwerk oder Zugangsdaten benötigen.

## Provider konfigurieren

<Steps>
  <Step title="Pi installieren">
    Installieren Sie Pi global mit npm:

    ```bash theme={null}
    npm install -g --ignore-scripts @earendil-works/pi-coding-agent
    ```

    Bestätigen Sie, dass die CLI verfügbar ist:

    ```bash theme={null}
    pi --version
    ```
  </Step>

  <Step title="Ihren CometAPI API key festlegen">
    Speichern Sie Ihren CometAPI API key in der Umgebungsvariable `COMETAPI_KEY`:

    ```bash theme={null}
    read -rsp "CometAPI API key: " COMETAPI_KEY
    printf '\n'
    export COMETAPI_KEY
    ```

    Fügen Sie den export-Befehl Ihrem Shell-Profil hinzu, wenn er über Terminal-Sitzungen hinweg bestehen bleiben soll. Committen Sie keine API keys in die Versionsverwaltung.
  </Step>

  <Step title="CometAPI-Provider zu models.json hinzufügen">
    Erstellen Sie `~/.pi/agent/models.json`, falls die Datei noch nicht existiert. Wenn die Datei bereits Provider enthält, führen Sie die Einträge `cometapi-responses` und `cometapi-chat` im vorhandenen `providers`-Objekt zusammen:

    ```json theme={null}
    {
      "providers": {
        "cometapi-responses": {
          "name": "CometAPI Responses",
          "baseUrl": "https://api.cometapi.com/v1",
          "api": "openai-responses",
          "apiKey": "$COMETAPI_KEY",
          "models": [
            {
              "id": "your-model-id",
              "name": "CometAPI Responses model"
            }
          ]
        },
        "cometapi-chat": {
          "name": "CometAPI Chat Completions",
          "baseUrl": "https://api.cometapi.com/v1",
          "api": "openai-completions",
          "apiKey": "$COMETAPI_KEY",
          "models": [
            {
              "id": "your-model-id",
              "name": "CometAPI Chat model"
            }
          ]
        }
      }
    }
    ```

    Verwenden Sie `cometapi-responses` für Modelle oder Workflows, die die OpenAI Responses API erfordern. Verwenden Sie `cometapi-chat` für Modelle, die mit OpenAI Chat Completions kompatibel sind. Pi löst `$COMETAPI_KEY` zur Request-Zeit auf. Bewahren Sie den API key in Ihrer Umgebung oder in Ihrem eigenen Secrets-Workflow auf.
  </Step>

  <Step title="Beide Provider überprüfen">
    Listen Sie die Modelle auf, die Pi für den Responses-Provider sehen kann:

    ```bash theme={null}
    pi --list-models cometapi-responses
    ```

    Führen Sie einen kurzen einmaligen Prompt mit dem Responses-Provider aus:

    ```bash theme={null}
    pi --provider cometapi-responses --model your-model-id -p "Reply with one short sentence confirming the Responses connection."
    ```

    Listen Sie die Modelle auf, die Pi für den Chat Completions-Provider sehen kann:

    ```bash theme={null}
    pi --list-models cometapi-chat
    ```

    Führen Sie einen kurzen einmaligen Prompt mit dem Chat Completions-Provider aus:

    ```bash theme={null}
    pi --provider cometapi-chat --model your-model-id -p "Reply with one short sentence confirming the Chat Completions connection."
    ```

    Für die interaktive Verwendung starten Sie Pi in Ihrem Projekt und wählen den CometAPI-Provider und das Modell mit `/model` aus. Wenn Sie `models.json` während einer interaktiven Sitzung bearbeiten, öffnen Sie `/model` erneut, damit Pi die benutzerdefinierten Modelleinträge neu lädt.
  </Step>
</Steps>

## Fehlerbehebung

<AccordionGroup>
  <Accordion title="Pi zeigt das CometAPI-Modell nicht an">
    Bestätige, dass `~/.pi/agent/models.json` gültiges JSON ist und dass sich jeder provider-Eintrag innerhalb des `providers`-Objekts der obersten Ebene befindet. Führe `pi --list-models cometapi-responses` oder `pi --list-models cometapi-chat` aus, nachdem du die Datei gespeichert hast.
  </Accordion>

  <Accordion title="Pi meldet, dass kein API-Schlüssel verfügbar ist">
    Bestätige, dass `COMETAPI_KEY` in derselben Shell-Sitzung gesetzt ist, die Pi startet. Wenn du ein Shell-Profil verwendest, öffne ein neues Terminal oder lade das Profil, bevor du Pi ausführst.
  </Accordion>

  <Accordion title="Anfragen schlagen wegen der base URL fehl">
    Verwende `https://api.cometapi.com/v1` als `baseUrl` in `models.json`. Richte Pi nicht auf die Dashboard-URL und lasse das Suffix `/v1` für OpenAI-kompatible Routen nicht weg.
  </Accordion>

  <Accordion title="Pi schlägt fehl, bevor eine Modellanfrage gesendet wird">
    Prüfe deine Node.js-Version mit `node --version`. Das Pi-Paket erfordert Node.js `>=22.19.0`.
  </Accordion>

  <Accordion title="Das Modell funktioniert auf einer Route, aber nicht auf der anderen">
    Verwende den provider-Eintrag, dessen Feld `api` mit der Route übereinstimmt, die dein Modell unterstützt. `openai-responses` verwendet die Responses API, während `openai-completions` Chat Completions verwendet.
  </Accordion>

  <Accordion title="Pi hat mehr Zugriff als erwartet">
    Pi läuft mit den Berechtigungen des Benutzers und Prozesses, der es gestartet hat. Führe Pi in einem Container oder einer Sandbox aus, wenn du strengere Grenzen für Dateien, Prozesse, Netzwerkzugriff oder Zugangsdaten benötigst.
  </Accordion>
</AccordionGroup>

## Verwandte Ressourcen

* [CometAPI-Schnellstart](/de/overview/quick-start)
* [CometAPI Models-Seite](/de/overview/models)
* [Benutzerdefinierte Pi-Modelle](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)
* [Pi CLI-Verwendung](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/usage.md)

<script type="application/ld+json">
  {`
    {
    "@context": "https://schema.org",
    "@graph": [
      {
        "@type": "HowTo",
        "@id": "https://apidoc.cometapi.com/integrations/pi#howto",
        "name": "Pi mit CometAPI verwenden",
        "description": "Verwenden Sie diese Anleitung, um Pi mit CometAPI zu konfigurieren, indem Sie die base URL, den API-Schlüssel und model- oder provider-Optionen festlegen.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-1",
            "position": 1,
            "name": "Pi installieren",
            "text": "Führen Sie den Schritt „Pi installieren“ in der Anleitung „Pi mit CometAPI verwenden“ aus."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-2",
            "position": 2,
            "name": "Ihren CometAPI-API-Schlüssel festlegen",
            "text": "Speichern Sie Ihren CometAPI-API-Schlüssel in der Umgebungsvariable oder im Einstellungsfeld, das von der Integration verwendet wird."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-3",
            "position": 3,
            "name": "CometAPI-provider zu models.json hinzufügen",
            "text": "Führen Sie den Schritt „CometAPI-provider zu models.json hinzufügen“ in der Anleitung „Pi mit CometAPI verwenden“ aus."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-4",
            "position": 4,
            "name": "Beide provider überprüfen",
            "text": "Führen Sie den Schritt „Beide provider überprüfen“ in der Anleitung „Pi mit CometAPI verwenden“ aus."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "CometAPI-Dokumentation",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Integrationen",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Pi mit CometAPI verwenden",
            "item": "https://apidoc.cometapi.com/integrations/pi"
          }
        ]
      }
    ]
    }
    `}
</script>