> ## 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.

# Utiliser Pi avec CometAPI

> Utilisez ce guide pour configurer Pi avec CometAPI en définissant l’URL de base, la clé API et les options de modèle ou de fournisseur.

[Pi](https://github.com/earendil-works/pi) est le projet Pi Agent Harness. Son package `@earendil-works/pi-coding-agent` fournit une CLI d’agent de code interactive avec des workflows de fichier, shell, édition, écriture, session, affichage, JSON, RPC et SDK. Pi peut charger des fournisseurs personnalisés depuis `~/.pi/agent/models.json`, vous pouvez donc ajouter CometAPI comme entrées de fournisseur compatibles OpenAI sans modifier le code source de Pi.

Références officielles :

* [Dépôt Pi](https://github.com/earendil-works/pi)
* [Démarrage rapide Pi](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/quickstart.md)
* [Fournisseurs Pi](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/providers.md)
* [Modèles personnalisés Pi](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)
* [Utilisation de la CLI Pi](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/usage.md)

<Note>
  La disponibilité des modèles évolue au fil du temps. Remplacez `your-model-id` par un model ID disponible depuis la [page des modèles CometAPI](/fr/overview/models).
</Note>

## Prérequis

* Node.js `>=22.19.0`
* npm
* Un compte CometAPI avec une clé API active depuis le [tableau de bord](https://www.cometapi.com/console/token)
* Pi installé depuis le package npm officiel

## Comprendre les autorisations d’exécution

Pi s’exécute avec les autorisations de l’utilisateur et du processus qui le lance. Démarrez Pi dans le répertoire du projet sur lequel vous souhaitez qu’il travaille, conservez une possibilité de retour en arrière comme git, et utilisez un conteneur ou un bac à sable si vous avez besoin de limites plus strictes pour le système de fichiers, les processus, le réseau ou les identifiants.

## Configurer le fournisseur

<Steps>
  <Step title="Installer Pi">
    Installez Pi globalement avec npm :

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

    Confirmez que la CLI est disponible :

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

  <Step title="Définir votre clé API CometAPI">
    Stockez votre clé API CometAPI dans la variable d’environnement `COMETAPI_KEY` :

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

    Ajoutez la commande d’export à votre profil shell si vous souhaitez qu’elle persiste entre les sessions de terminal. Ne validez pas de clés API dans votre système de contrôle de version.
  </Step>

  <Step title="Ajouter des fournisseurs CometAPI à models.json">
    Créez `~/.pi/agent/models.json` s’il n’existe pas. Si le fichier contient déjà des fournisseurs, fusionnez les entrées `cometapi-responses` et `cometapi-chat` dans l’objet `providers` existant :

    ```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"
            }
          ]
        }
      }
    }
    ```

    Utilisez `cometapi-responses` pour les modèles ou workflows qui nécessitent l’API OpenAI Responses. Utilisez `cometapi-chat` pour les modèles compatibles OpenAI Chat Completions. Pi résout `$COMETAPI_KEY` au moment de la requête. Conservez la clé API dans votre environnement ou dans votre propre workflow de gestion des secrets.
  </Step>

  <Step title="Vérifier les deux fournisseurs">
    Listez les modèles que Pi peut voir pour le fournisseur Responses :

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

    Exécutez un court Prompt ponctuel avec le fournisseur Responses :

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

    Listez les modèles que Pi peut voir pour le fournisseur Chat Completions :

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

    Exécutez un court Prompt ponctuel avec le fournisseur Chat Completions :

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

    Pour une utilisation interactive, démarrez Pi dans votre projet et sélectionnez le fournisseur et le modèle CometAPI avec `/model`. Si vous modifiez `models.json` pendant une session interactive, ouvrez à nouveau `/model` afin que Pi recharge les entrées de modèle personnalisées.
  </Step>
</Steps>

## Dépannage

<AccordionGroup>
  <Accordion title="Pi n’affiche pas le modèle CometAPI">
    Vérifiez que `~/.pi/agent/models.json` est un JSON valide et que chaque entrée de fournisseur se trouve à l’intérieur de l’objet `providers` de niveau supérieur. Exécutez `pi --list-models cometapi-responses` ou `pi --list-models cometapi-chat` après avoir enregistré le fichier.
  </Accordion>

  <Accordion title="Pi signale qu’aucune clé API n’est disponible">
    Vérifiez que `COMETAPI_KEY` est défini dans la même session shell qui lance Pi. Si vous utilisez un profil shell, ouvrez un nouveau terminal ou rechargez le profil avant d’exécuter Pi.
  </Accordion>

  <Accordion title="Les requêtes échouent à cause de l’URL de base">
    Utilisez `https://api.cometapi.com/v1` comme `baseUrl` dans `models.json`. Ne faites pas pointer Pi vers l’URL du tableau de bord et n’omettez pas le suffixe `/v1` pour les routes compatibles OpenAI.
  </Accordion>

  <Accordion title="Pi échoue avant d’envoyer une requête au modèle">
    Vérifiez votre version de Node.js avec `node --version`. Le package Pi nécessite Node.js `>=22.19.0`.
  </Accordion>

  <Accordion title="Le modèle fonctionne sur une route mais pas sur l’autre">
    Utilisez l’entrée de fournisseur dont le champ `api` correspond à la route prise en charge par votre modèle. `openai-responses` utilise l’API Responses, tandis que `openai-completions` utilise Chat Completions.
  </Accordion>

  <Accordion title="Pi a plus d’accès que prévu">
    Pi s’exécute avec les autorisations de l’utilisateur et du processus qui l’ont lancé. Exécutez Pi dans un conteneur ou un bac à sable lorsque vous avez besoin de limites plus strictes autour des fichiers, des processus, de l’accès réseau ou des identifiants.
  </Accordion>
</AccordionGroup>

## Ressources associées

* [Démarrage rapide de CometAPI](/fr/overview/quick-start)
* [Page Models de CometAPI](/fr/overview/models)
* [Modèles personnalisés Pi](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)
* [Utilisation de Pi CLI](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": "Utiliser Pi avec CometAPI",
        "description": "Utilisez ce guide pour configurer Pi avec CometAPI en définissant l’URL de base, la clé API et les options de modèle ou de fournisseur.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-1",
            "position": 1,
            "name": "Installer Pi",
            "text": "Effectuez l’étape Installer Pi dans le guide Utiliser Pi avec CometAPI."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-2",
            "position": 2,
            "name": "Définir votre clé API CometAPI",
            "text": "Stockez votre clé API CometAPI dans la variable d’environnement ou le champ de paramètres utilisé par l’intégration."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-3",
            "position": 3,
            "name": "Ajouter des fournisseurs CometAPI à models.json",
            "text": "Effectuez l’étape Ajouter des fournisseurs CometAPI à models.json dans le guide Utiliser Pi avec CometAPI."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-4",
            "position": 4,
            "name": "Vérifier les deux fournisseurs",
            "text": "Effectuez l’étape Vérifier les deux fournisseurs dans le guide Utiliser Pi avec CometAPI."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "Documentation CometAPI",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Intégrations",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Utiliser Pi avec CometAPI",
            "item": "https://apidoc.cometapi.com/integrations/pi"
          }
        ]
      }
    ]
    }
    `}
</script>