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

# Quickstart

> De zéro à tes clés API protégées en 60 secondes, sans fichier .env.

## En 4 commandes

<Steps>
  <Step title="Installe le CLI">
    ```bash theme={null}
    npm install -g @elding/cli
    ```
  </Step>

  <Step title="Connecte-toi">
    ```bash theme={null}
    elding login
    ```

    Ouvre le navigateur, autorise, c'est fait. Le token est stocké localement (chmod 600).
  </Step>

  <Step title="Crée un set + ajoute tes clés">
    Dans le [dashboard](https://elding.app), crée un set (ex. `dev`) et ajoute tes clés.
    Puis lie ton projet :

    ```bash theme={null}
    elding init
    ```
  </Step>

  <Step title="Lance ton app derrière le proxy">
    Préfixe ta commande habituelle par `elding proxy --` :

    ```bash theme={null}
    elding proxy -- node app.js
    ```

    <Check>
      Tes clés API sont chargées **dans le proxy**, jamais dans la mémoire de ton app.
    </Check>
  </Step>
</Steps>

## Intègre-le à ton `npm run dev`

Pour ne plus y penser, mets `elding proxy --` dans le script `dev` de ton `package.json` :

```json package.json theme={null}
{
  "scripts": {
    "dev": "elding proxy -- next dev"
  }
}
```

Maintenant tu lances ton app comme d'habitude, la clé est protégée en transparence :

```bash theme={null}
npm run dev
```

<Note>
  Ça marche avec n'importe quelle commande : `next dev`, `vite`, `node server.js`, `nodemon`...
  Tu gardes ton workflow exact, Elding s'ajoute par-dessus.
</Note>

## Le moment magique

Dans ton code, une seule ligne. `configure()` s'occupe de tout :

```js app.js theme={null}
import OpenAI from "openai";
import { configure } from "@elding/sdk";

const openai = new OpenAI(
  await configure("OPENAI_API_KEY", "https://api.openai.com")
);
// la vraie clé n'entre jamais dans ton app
```

Maintenant essaie de logger la clé :

```js theme={null}
console.log(process.env.OPENAI_API_KEY); // → undefined ou {{OPENAI_API_KEY}}
```

<Note>
  La requête vers OpenAI **fonctionne** : le proxy injecte la vraie clé au dernier moment,
  verrouillée sur `api.openai.com`. Mais ton app, ton agent IA et tes dépendances ne voient
  qu'un placeholder. **La vraie clé n'existe nulle part dans ton process.**
</Note>

## Déployer en production

Ça marche en dev. Maintenant tu le ships. Lance une seule fois, en local :

```bash theme={null}
elding deploy
```

Le CLI demande un nom pour la clé, la crée, et affiche deux variables :

```
  ELDING_REFRESH_TOKEN=eld_rt_...
  ELDING_SET_ID=...
```

Ajoute-les dans les réglages de ton hébergeur (Vercel → Settings → Environment Variables, Railway, Render, etc.). Ton code ne change pas : le SDK bascule automatiquement du proxy local vers le vault.

<Warning>
  Copie le token immédiatement. Il n'est affiché qu'une seule fois.
  Ne lance pas `elding deploy` dans un pipeline CI aux logs publics.
</Warning>

<Card title="Toutes les options de déploiement" icon="rocket" href="/fr/sdk/deploy">
  Méthode CLI, méthode dashboard, révocation.
</Card>

## Et après ?

<CardGroup cols={1}>
  <Card title="Comprendre le proxy" icon="shield" href="/fr/concepts/proxy">
    Comment l'injection et le host-lock fonctionnent.
  </Card>
</CardGroup>