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

# Antigravity

> Agrega firmas electrónicas legalmente vinculantes a cualquier proyecto usando Google Antigravity CLI o Antigravity Desktop con los servidores MCP de Firma.

Firma te permite agregar firmas electrónicas legalmente vinculantes a cualquier cosa que construyas con Google Antigravity. Conecta los servidores MCP de Firma a Antigravity CLI o Antigravity Desktop y el agente podrá generar código de integración de Firma preciso, gestionar tus Solicitudes de Firma y operar directamente sobre tus datos de Firma desde la terminal o el IDE.

Esta guía cubre dos formas de usar Firma con Antigravity:

1. **Antigravity CLI** - Agente basado en terminal con soporte para MCP. Ideal para desarrolladores que trabajan en la terminal.
2. **Antigravity Desktop** - IDE independiente con la misma configuración de MCP. Ideal para desarrolladores que prefieren un editor visual.

## Requisitos previos

* Una [cuenta de Firma](https://app.firma.dev) con una Clave API
* Antigravity CLI o Antigravity Desktop instalado
* Al menos una Plantilla de Firma con campos de firma configurados

<Note>
  Firma usa la Clave API sin procesar como valor del encabezado `Authorization`; no la antepongas con `Bearer`. Esto difiere de muchas otras API.
</Note>

## Primeros pasos

<Tabs>
  <Tab title="Antigravity CLI">
    Antigravity CLI (`agy`) es un agente de IA basado en terminal que admite servidores MCP para la integración de herramientas externas. Conectar los servidores MCP de Firma le permite al agente construir integraciones de Firma y operar sobre tus datos de Firma.

    ### Paso 1: Instala Antigravity CLI

    Si aún no lo has hecho, instala el CLI:

    ```bash theme={null}
    curl -fsSL https://antigravity.google/cli/install.sh | bash
    ```

    En Windows (PowerShell):

    ```powershell theme={null}
    irm https://antigravity.google/cli/install.ps1 | iex
    ```

    El binario se instala como `agy`. Es posible que debas agregar `~/.local/bin` a tu PATH.

    ### Paso 2: Agrega los servidores MCP de Firma

    Crea o edita `~/.gemini/antigravity/mcp_config.json` y agrega ambos servidores de Firma:

    ```json theme={null}
    {
      "mcpServers": {
        "firma-api": {
          "serverUrl": "https://mcp.firma.dev/mcp"
        },
        "firma-docs": {
          "serverUrl": "https://docs.firma.dev/mcp"
        }
      }
    }
    ```

    * **firma-api** le da a Antigravity acceso directo a la API de Firma: 84 herramientas para Solicitudes de Firma, Plantillas, Espacios de Trabajo y webhooks.
    * **firma-docs** le da a Antigravity acceso a toda la documentación de Firma para que genere código de integración preciso.

    Reinicia el CLI después de guardar la configuración. En el primer uso de una herramienta de Firma, Antigravity te guiará para iniciar sesión con tu cuenta de Firma mediante OAuth.

    <Note>
      Cuándo usar cada servidor: `firma-api` es para hacer cosas (enviar Solicitudes de Firma, gestionar Plantillas). `firma-docs` es para construir cosas (generar código de integración con detalles precisos de la API). La mayoría de los desarrolladores querrán ambos conectados.
    </Note>

    ### Paso 3: Usa Firma desde el CLI

    Una vez conectado, puedes pedirle a Antigravity que construya integraciones de Firma u opere sobre tus datos:

    **Generar una integración de backend:**

    ```text theme={null}
    Using the Firma API docs, create an Express route that:
    1. Accepts a name, template_id, signer email, and signer name
    2. Uses the create-and-send endpoint to send a signing request
    3. Returns the signing request ID and the signer's signing link
    Store the API key in process.env.FIRMA_API_KEY.
    ```

    **Listar tus Solicitudes de Firma:**

    ```text theme={null}
    List all pending signing requests in my default workspace.
    ```

    **Enviar una Solicitud de Firma:**

    ```text theme={null}
    Create a signing request from the NDA template and send it to jane@example.com
    ```

    **Agregar firma incrustada a una app de React:**

    ```text theme={null}
    Using the Firma docs, add an embedded signing view to this React app.
    After a signing request is created, render the signer's signing_link
    in an iframe.
    ```

    **Configurar webhooks:**

    ```text theme={null}
    Using the Firma docs, create a webhook handler that listens for
    signing_request.completed events and updates the contract status
    in our Postgres database.
    ```

    Referirse explícitamente a "los docs de Firma" le indica al agente que consulte el servidor MCP `firma-docs` antes de escribir código. Sin eso, puede recurrir a conocimiento general y pasar por alto detalles de endpoints o autenticación.
  </Tab>

  <Tab title="Antigravity Desktop">
    Antigravity Desktop es un IDE independiente que usa la misma configuración de MCP que el CLI. Si ya configuraste el CLI, la app de Desktop detecta los mismos servidores automáticamente.

    ### Paso 1: Instala Antigravity Desktop

    Descarga e instala Antigravity Desktop desde [antigravity.google](https://antigravity.google).

    ### Paso 2: Agrega los servidores MCP de Firma

    Antigravity Desktop lee el mismo archivo de configuración que el CLI. Crea o edita `~/.gemini/antigravity/mcp_config.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "firma-api": {
          "serverUrl": "https://mcp.firma.dev/mcp"
        },
        "firma-docs": {
          "serverUrl": "https://docs.firma.dev/mcp"
        }
      }
    }
    ```

    Reinicia Antigravity Desktop después de guardar la configuración.

    ### Paso 3: Construye integraciones de Firma desde el IDE

    Con los servidores MCP conectados, usa el chat del agente en Antigravity Desktop de la misma forma que lo harías en el CLI. El agente puede leer los archivos de tu proyecto, generar código de integración de Firma y configurar endpoints, todo dentro del IDE.

    Los mismos prompts de la pestaña del CLI funcionan en el chat de Desktop. El agente de Desktop tiene la ventaja adicional de ver el contexto completo de tu proyecto, por lo que puede generar código que se ajuste a tu arquitectura existente.
  </Tab>
</Tabs>

## Qué genera el agente

Cuando le pides a Antigravity que construya una integración de Firma, el código de backend generado debería verse así:

```typescript theme={null}
import express from "express";

const FIRMA_API = "https://api.firma.dev/functions/v1/signing-request-api";
const app = express();
app.use(express.json());

app.post("/api/signing-requests", async (req, res) => {
  const { name, template_id, signer_email, signer_first_name, signer_last_name } =
    req.body;

  const response = await fetch(
    `${FIRMA_API}/signing-requests/create-and-send`,
    {
      method: "POST",
      headers: {
        Authorization: process.env.FIRMA_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        name,
        template_id,
        recipients: [
          {
            first_name: signer_first_name,
            last_name: signer_last_name,
            email: signer_email,
            designation: "Signer",
            order: 1,
          },
        ],
      }),
    }
  );

  const data = await response.json();

  if (!response.ok) return res.status(response.status).json({ error: data });
  res.json({
    signing_request_id: data.id,
    signing_request_user_id: data.first_signer.id,
    signing_link: data.first_signer.signing_link,
  });
});

app.listen(3000);
```

El endpoint `create-and-send` crea la Solicitud de Firma y la envía a los Destinatarios de forma atómica. Si necesitas revisar o modificar la solicitud antes de enviarla, usa `POST /signing-requests` para crear un borrador y luego `POST /signing-requests/{id}/send` por separado.

<Warning>
  Nunca expongas tu Clave API en código de frontend. Llama siempre a la API de Firma desde un backend donde los secretos se mantengan seguros.
</Warning>

## Integración de webhooks

Para rastrear eventos de firma en tiempo real, pídele a Antigravity que agregue un manejador de webhooks:

```text theme={null}
Using the Firma docs, create a webhook handler that receives Firma events.
When signing_request.completed fires, update the contract record in the database.
```

El agente generará algo como esto:

```typescript theme={null}
app.post("/api/firma-webhook", async (req, res) => {
  const { type, data } = req.body;

  if (type === "signing_request.completed") {
    const signingRequestId = data.signing_request.id;
    // Update your database or trigger the next workflow step.
  }

  res.json({ received: true });
});
```

En el panel de Firma, en **Configuración > Webhooks**, registra la URL de tu endpoint. Firma envía eventos para todos los cambios de estado importantes. Consulta la [guía de webhooks](/es/guides/webhooks) para ver la lista completa de eventos y la verificación de firma.

<Warning>
  Verifica siempre la firma del webhook usando tu secreto de firma de webhook de Firma en producción. Consulta la [guía de webhooks](/es/guides/webhooks) para los detalles de implementación.
</Warning>

## Firma incrustada

Para apps donde los Firmantes completan documentos dentro de tu interfaz en lugar de abrir una página alojada por Firma, la respuesta de `create-and-send` incluye `first_signer.id` (el `signing_request_user_id`) y un `first_signer.signing_link` ya generado. Carga la URL del Firmante en un iframe:

```html theme={null}
<iframe
  src="https://app.firma.dev/signing/{signing_request_user_id}"
  style="width:100%;height:900px;border:0;"
  allow="camera;microphone;clipboard-write"
  title="Document Signing"
></iframe>
```

Consulta la [guía de firma incrustada](/es/guides/embeddable-signing) para la configuración completa, incluidas las mejores prácticas de seguridad.

## Migración desde Gemini CLI

Si antes usabas Firma con Gemini CLI, esto es lo que cambió:

| Gemini CLI                        | Antigravity CLI                         |
| --------------------------------- | --------------------------------------- |
| `~/.gemini/settings.json`         | `~/.gemini/antigravity/mcp_config.json` |
| `httpUrl` para servidores remotos | `serverUrl` para servidores remotos     |
| binario `gemini`                  | binario `agy`                           |

Importa tus plugins existentes de Gemini CLI:

```bash theme={null}
agy plugin import gemini
```

<Note>
  Gemini CLI deja de dar servicio a usuarios del nivel individual el 18 de junio de 2026. Si tienes una licencia Gemini Code Assist Standard/Enterprise, las extensiones de IDE de Gemini CLI seguirán funcionando.
</Note>

## Consejos

* **Usa `firma-docs` para construir, `firma-api` para operar.** El servidor de docs ayuda al agente a escribir código de integración correcto. El servidor de la API le permite al agente gestionar Solicitudes de Firma, Plantillas y Espacios de Trabajo directamente.
* **Pasa `template_id` explícitamente.** Las Plantillas son la forma más segura de limitar lo que el agente puede enviar. Deja que el agente elija un ID de Plantilla de una lista corta y con nombre que tú controles.
* **Valida antes de enviar.** Para documentos de mayor riesgo, pídele al agente que cree un borrador con `POST /signing-requests` y que confirme antes de llamar a `POST /signing-requests/{id}/send`.
* **Espacios de Trabajo para apps multiusuario.** Si estás construyendo un producto SaaS, dale a cada cliente final su propio Espacio de Trabajo de Firma para que las Plantillas y el uso se mantengan aislados.

## Próximos pasos

* [Autenticación de la API](/es/guides/authentication) - Claves API y alcance de Espacios de Trabajo
* [Guía de webhooks](/es/guides/webhooks) - Tipos de eventos, payloads y verificación de firma
* [Firma incrustada](/es/guides/embeddable-signing) - Experiencia de firma dentro de la app
* [Creación de Espacios de Trabajo](/es/guides/creating-workspaces) - Configuraciones multiusuario para apps SaaS
* [Integración MCP](/es/guides/mcp) - Referencia completa del servidor MCP con las 84 herramientas
* [Guía de configuración completa](/es/guides/complete-setup-guide) - Recorrido de integración de Firma de principio a fin
* [Referencia de la API](/api-reference) - Documentación completa de endpoints