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

> Ajoutez des signatures électroniques juridiquement contraignantes à n'importe quel projet grâce à Google Antigravity CLI ou Antigravity Desktop avec les serveurs MCP de Firma.

Firma vous permet d'ajouter des signatures électroniques juridiquement contraignantes à tout ce que vous construisez avec Google Antigravity. Connectez les serveurs MCP de Firma à Antigravity CLI ou à Antigravity Desktop, et l'agent peut générer du code d'intégration Firma précis, gérer vos demandes de signature et opérer directement sur vos données Firma depuis le terminal ou l'IDE.

Ce guide couvre deux façons d'utiliser Firma avec Antigravity :

1. **Antigravity CLI** - Agent basé sur le terminal avec prise en charge de MCP. Idéal pour les développeurs qui travaillent dans le terminal.
2. **Antigravity Desktop** - IDE autonome avec la même configuration MCP. Idéal pour les développeurs qui préfèrent un éditeur visuel.

## Prérequis

* Un [compte Firma](https://app.firma.dev) avec une clé API
* Antigravity CLI ou Antigravity Desktop installé
* Au moins un modèle Firma avec des champs de signature configurés

<Note>
  Firma utilise la clé API brute comme valeur de l'en-tête `Authorization` - ne la préfixez pas avec `Bearer`. Cela diffère de nombreuses autres API.
</Note>

## Pour commencer

<Tabs>
  <Tab title="Antigravity CLI">
    Antigravity CLI (`agy`) est un agent IA basé sur le terminal qui prend en charge les serveurs MCP pour l'intégration d'outils externes. Connecter les serveurs MCP de Firma permet à l'agent de construire des intégrations Firma et d'opérer sur vos données Firma.

    ### Étape 1 : Installer Antigravity CLI

    Si ce n'est pas déjà fait, installez le CLI :

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

    Sur Windows (PowerShell) :

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

    Le binaire s'installe sous le nom `agy`. Vous devrez peut-être ajouter `~/.local/bin` à votre PATH.

    ### Étape 2 : Ajouter les serveurs MCP de Firma

    Créez ou modifiez `~/.gemini/antigravity/mcp_config.json` et ajoutez les deux serveurs Firma :

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

    * **firma-api** donne à Antigravity un accès direct à l'API Firma - 84 outils couvrant les demandes de signature, les modèles, les espaces de travail et les webhooks.
    * **firma-docs** donne à Antigravity accès à l'ensemble de la documentation Firma afin qu'il génère du code d'intégration précis.

    Redémarrez le CLI après avoir enregistré la configuration. Lors de la première utilisation d'un outil Firma, Antigravity vous guidera pour vous connecter avec votre compte Firma via OAuth.

    <Note>
      Quand utiliser quel serveur : `firma-api` sert à faire des choses (envoyer des demandes de signature, gérer des modèles). `firma-docs` sert à construire des choses (générer du code d'intégration avec des détails d'API précis). La plupart des développeurs veulent connecter les deux.
    </Note>

    ### Étape 3 : Utiliser Firma depuis le CLI

    Une fois connecté, vous pouvez demander à Antigravity de construire des intégrations Firma ou d'opérer sur vos données :

    **Générer une intégration 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.
    ```

    **Lister vos demandes de signature :**

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

    **Envoyer une demande de signature :**

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

    **Ajouter une signature intégrée à une application 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.
    ```

    **Configurer des 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.
    ```

    Faire référence explicitement à « la documentation Firma » indique à l'agent d'interroger le serveur MCP `firma-docs` avant d'écrire du code. Sans cela, il peut se rabattre sur des connaissances générales et manquer des détails sur les endpoints ou l'authentification.
  </Tab>

  <Tab title="Antigravity Desktop">
    Antigravity Desktop est un IDE autonome qui utilise la même configuration MCP que le CLI. Si vous avez déjà configuré le CLI, l'application Desktop reprend automatiquement les mêmes serveurs.

    ### Étape 1 : Installer Antigravity Desktop

    Téléchargez et installez Antigravity Desktop depuis [antigravity.google](https://antigravity.google).

    ### Étape 2 : Ajouter les serveurs MCP de Firma

    Antigravity Desktop lit le même fichier de configuration que le CLI. Créez ou modifiez `~/.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"
        }
      }
    }
    ```

    Redémarrez Antigravity Desktop après avoir enregistré la configuration.

    ### Étape 3 : Construire des intégrations Firma depuis l'IDE

    Une fois les serveurs MCP connectés, utilisez le chat de l'agent dans Antigravity Desktop de la même manière que dans le CLI. L'agent peut lire les fichiers de votre projet, générer du code d'intégration Firma et configurer des endpoints - le tout depuis l'IDE.

    Les mêmes prompts que dans l'onglet CLI fonctionnent dans le chat Desktop. L'agent Desktop bénéficie de l'avantage supplémentaire de voir tout le contexte de votre projet, ce qui lui permet de générer du code adapté à votre architecture existante.
  </Tab>
</Tabs>

## Ce que l'agent génère

Lorsque vous demandez à Antigravity de construire une intégration Firma, le code backend généré devrait ressembler à ceci :

```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);
```

L'endpoint `create-and-send` crée la demande de signature et l'envoie aux destinataires de manière atomique. Si vous devez examiner ou modifier la demande avant l'envoi, utilisez `POST /signing-requests` pour créer un brouillon, puis `POST /signing-requests/{id}/send` séparément.

<Warning>
  N'exposez jamais votre clé API dans du code frontend. Appelez toujours l'API Firma depuis un backend où les secrets sont conservés en sécurité.
</Warning>

## Intégration des webhooks

Pour suivre les événements de signature en temps réel, demandez à Antigravity d'ajouter un gestionnaire de webhook :

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

L'agent générera quelque chose comme ceci :

```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 });
});
```

Dans le tableau de bord Firma, sous **Paramètres > Webhooks**, enregistrez l'URL de votre endpoint. Firma envoie des événements pour tous les changements d'état majeurs. Consultez le [guide des webhooks](/fr/guides/webhooks) pour la liste complète des événements et la vérification de signature.

<Warning>
  Vérifiez toujours la signature du webhook à l'aide de votre secret de signature webhook Firma en production. Consultez le [guide des webhooks](/fr/guides/webhooks) pour les détails d'implémentation.
</Warning>

## Signature intégrée

Pour les applications où les signataires complètent les documents directement dans votre interface utilisateur plutôt que d'ouvrir une page hébergée par Firma, la réponse `create-and-send` inclut `first_signer.id` (le `signing_request_user_id`) et un `first_signer.signing_link` prêt à l'emploi. Chargez l'URL du signataire dans une 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>
```

Consultez le [guide de la signature intégrée](/fr/guides/embeddable-signing) pour la configuration complète, y compris les bonnes pratiques de sécurité.

## Migration depuis Gemini CLI

Si vous utilisiez auparavant Firma avec Gemini CLI, voici ce qui a changé :

| Gemini CLI                           | Antigravity CLI                         |
| ------------------------------------ | --------------------------------------- |
| `~/.gemini/settings.json`            | `~/.gemini/antigravity/mcp_config.json` |
| `httpUrl` pour les serveurs distants | `serverUrl` pour les serveurs distants  |
| binaire `gemini`                     | binaire `agy`                           |

Importez vos plugins Gemini CLI existants :

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

<Note>
  Gemini CLI cesse de fonctionner pour les utilisateurs de niveau individuel le 18 juin 2026. Si vous disposez d'une licence Gemini Code Assist Standard/Enterprise, les extensions IDE de Gemini CLI continuent de fonctionner.
</Note>

## Conseils

* **Utilisez `firma-docs` pour construire, `firma-api` pour opérer.** Le serveur de documentation aide l'agent à écrire du code d'intégration correct. Le serveur API permet à l'agent de gérer directement les demandes de signature, les modèles et les espaces de travail.
* **Passez `template_id` explicitement.** Les modèles sont le moyen le plus sûr de limiter ce que l'agent peut envoyer. Laissez l'agent choisir un ID de modèle dans une liste courte et nommée que vous contrôlez.
* **Validez avant d'envoyer.** Pour les documents à plus fort enjeu, demandez à l'agent de créer un brouillon avec `POST /signing-requests`, puis de confirmer avant d'appeler `POST /signing-requests/{id}/send`.
* **Espaces de travail pour les applications multi-tenant.** Si vous construisez un produit SaaS, donnez à chaque client final son propre espace de travail Firma afin que les modèles et l'utilisation restent isolés.

## Prochaines étapes

* [Authentification API](/fr/guides/authentication) - Clés API et périmètre des espaces de travail
* [Guide des webhooks](/fr/guides/webhooks) - Types d'événements, payloads et vérification de signature
* [Signature intégrée](/fr/guides/embeddable-signing) - Expérience de signature intégrée à l'application
* [Création d'espaces de travail](/fr/guides/creating-workspaces) - Configurations multi-tenant pour les applications SaaS
* [Intégration MCP](/fr/guides/mcp) - Référence complète du serveur MCP avec les 84 outils
* [Guide de configuration complet](/fr/guides/complete-setup-guide) - Parcours complet d'intégration Firma
* [Référence API](/api-reference) - Documentation complète des endpoints