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

# Usar Pi con CometAPI

> Usa esta guía para configurar Pi con CometAPI estableciendo la URL base, la API key y las opciones de model o provider.

[Pi](https://github.com/earendil-works/pi) es el proyecto Pi Agent Harness. Su paquete `@earendil-works/pi-coding-agent` ofrece un CLI interactivo de agente de programación con flujos de trabajo de archivos, shell, edición, escritura, sesión, impresión, JSON, RPC y SDK. Pi puede cargar providers personalizados desde `~/.pi/agent/models.json`, por lo que puedes agregar CometAPI como entradas de provider compatibles con OpenAI sin cambiar el código fuente de Pi.

Referencias oficiales:

* [Repositorio de Pi](https://github.com/earendil-works/pi)
* [Inicio rápido de Pi](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/quickstart.md)
* [Providers de Pi](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/providers.md)
* [Modelos personalizados de Pi](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)
* [Uso del CLI de Pi](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/usage.md)

<Note>
  La disponibilidad de los modelos cambia con el tiempo. Reemplaza `your-model-id` por un model ID disponible de la [página de modelos de CometAPI](/es/overview/models).
</Note>

## Prerrequisitos

* Node.js `>=22.19.0`
* npm
* Una cuenta de CometAPI con una API key activa desde el [panel](https://www.cometapi.com/console/token)
* Pi instalado desde el paquete oficial de npm

## Comprende los permisos de ejecución

Pi se ejecuta con los permisos del usuario y del proceso que lo inicia. Inicia Pi en el directorio del proyecto en el que quieres que trabaje, mantén una ruta de reversión como git y usa un contenedor o sandbox si necesitas límites más estrictos para el sistema de archivos, los procesos, la red o las credenciales.

## Configurar el proveedor

<Steps>
  <Step title="Instala Pi">
    Instala Pi globalmente con npm:

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

    Confirma que la CLI esté disponible:

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

  <Step title="Establece tu clave de API de CometAPI">
    Guarda tu clave de API de CometAPI en la variable de entorno `COMETAPI_KEY`:

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

    Agrega el comando de exportación a tu perfil de shell si quieres que persista entre sesiones de terminal. No subas claves de API al control de versiones.
  </Step>

  <Step title="Agrega proveedores de CometAPI a models.json">
    Crea `~/.pi/agent/models.json` si no existe. Si el archivo ya contiene proveedores, fusiona las entradas `cometapi-responses` y `cometapi-chat` dentro del objeto `providers` existente:

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

    Usa `cometapi-responses` para modelos o flujos de trabajo que requieran la API de OpenAI Responses. Usa `cometapi-chat` para modelos compatibles con OpenAI Chat Completions. Pi resuelve `$COMETAPI_KEY` en el momento de la solicitud. Mantén la clave de API en tu entorno o en tu propio flujo de trabajo de secretos.
  </Step>

  <Step title="Verifica ambos proveedores">
    Enumera los modelos que Pi puede ver para el proveedor de Responses:

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

    Ejecuta un Prompt corto de una sola vez con el proveedor de Responses:

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

    Enumera los modelos que Pi puede ver para el proveedor de Chat Completions:

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

    Ejecuta un Prompt corto de una sola vez con el proveedor de Chat Completions:

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

    Para uso interactivo, inicia Pi en tu proyecto y selecciona el proveedor y model de CometAPI con `/model`. Si editas `models.json` durante una sesión interactiva, abre `/model` de nuevo para que Pi recargue las entradas de modelos personalizadas.
  </Step>
</Steps>

## Solución de problemas

<AccordionGroup>
  <Accordion title="Pi no muestra el modelo de CometAPI">
    Confirma que `~/.pi/agent/models.json` sea JSON válido y que cada entrada de proveedor esté dentro del objeto `providers` de nivel superior. Ejecuta `pi --list-models cometapi-responses` o `pi --list-models cometapi-chat` después de guardar el archivo.
  </Accordion>

  <Accordion title="Pi informa que no hay ninguna API key disponible">
    Confirma que `COMETAPI_KEY` esté configurada en la misma sesión de shell que inicia Pi. Si usas un perfil de shell, abre una terminal nueva o vuelve a cargar el perfil antes de ejecutar Pi.
  </Accordion>

  <Accordion title="Las solicitudes fallan por la base URL">
    Usa `https://api.cometapi.com/v1` como `baseUrl` en `models.json`. No dirijas Pi a la URL del dashboard ni omitas el sufijo `/v1` para las rutas compatibles con OpenAI.
  </Accordion>

  <Accordion title="Pi falla antes de enviar una solicitud al modelo">
    Comprueba tu versión de Node.js con `node --version`. El paquete de Pi requiere Node.js `>=22.19.0`.
  </Accordion>

  <Accordion title="El modelo funciona en una ruta pero no en la otra">
    Usa la entrada de proveedor cuyo campo `api` coincida con la ruta que tu modelo admite. `openai-responses` usa la API de Responses, mientras que `openai-completions` usa Chat Completions.
  </Accordion>

  <Accordion title="Pi tiene más acceso del esperado">
    Pi se ejecuta con los permisos del usuario y del proceso que lo inició. Ejecuta Pi dentro de un contenedor o sandbox cuando necesites límites más estrictos en torno a archivos, procesos, acceso a la red o credenciales.
  </Accordion>
</AccordionGroup>

## Recursos relacionados

* [Inicio rápido de CometAPI](/es/overview/quick-start)
* [Página de modelos de CometAPI](/es/overview/models)
* [Modelos personalizados de Pi](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md)
* [Uso 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": "Usar Pi con CometAPI",
        "description": "Usa esta guía para configurar Pi con CometAPI estableciendo la URL base, la clave API y las opciones de model o provider.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-1",
            "position": 1,
            "name": "Instalar Pi",
            "text": "Completa el paso Instalar Pi en la guía Usar Pi con CometAPI."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-2",
            "position": 2,
            "name": "Configura tu clave API de CometAPI",
            "text": "Guarda tu clave API de CometAPI en la variable de entorno o en el campo de configuración utilizado por la integración."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-3",
            "position": 3,
            "name": "Agrega providers de CometAPI a models.json",
            "text": "Completa el paso Agrega providers de CometAPI a models.json en la guía Usar Pi con CometAPI."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/pi#step-4",
            "position": 4,
            "name": "Verifica ambos providers",
            "text": "Completa el paso Verifica ambos providers en la guía Usar Pi con CometAPI."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "Documentación de CometAPI",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Integraciones",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Usar Pi con CometAPI",
            "item": "https://apidoc.cometapi.com/integrations/pi"
          }
        ]
      }
    ]
    }
    `}
</script>