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

# Utiliser APIMart avec Gemini CLI

> Guide détaillé sur la configuration du service API APIMart dans l'outil en ligne de commande Gemini CLI. Apprenez à utiliser les modèles d'IA d'APIMart — y compris les séries Gemini, GPT et Claude — depuis le terminal.

## Introduction

Gemini CLI est l'outil officiel en ligne de commande de Google qui permet aux développeurs d'interagir avec les modèles d'IA Gemini depuis le terminal. Après avoir configuré l'API APIMart, vous pouvez utiliser les modèles avancés d'APIMart — GPT, Claude et Gemini — dans Gemini CLI.

## Prérequis

Avant de commencer :

1. **Node.js et npm installés**\
   Téléchargez et installez depuis le [site Node.js](https://nodejs.org/) (v16 ou plus récent recommandé)

2. **Clé API APIMart**\
   Connectez-vous à la [console APIMart](https://apimart.ai/keys) et copiez votre clé API (commence par `sk-`)

<Note>
  **Astuce :** si vous n'avez pas encore de compte APIMart, inscrivez-vous d'abord sur [APIMart](https://apimart.ai) et créez une clé API.
</Note>

## Étape 1 : Installer Gemini CLI

### 1.1 Installation globale

Installez Gemini CLI globalement avec npm :

```bash theme={null}
npm install -g @google/gemini-cli
```

### 1.2 Vérifier l'installation

Vérifiez que la CLI est disponible :

```bash theme={null}
gemini --version
```

Si un numéro de version s'affiche, l'installation a réussi.

<Note>**Astuce :** si la commande n'est pas trouvée, redémarrez votre terminal ou vérifiez votre configuration `PATH` globale npm.</Note>

## Étape 2 : Configurer l'API APIMart

### 2.1 Variables d'environnement temporaires

Pour des tests ou une utilisation ponctuelle ; les valeurs sont effacées à la fermeture du terminal.

**Windows (PowerShell) :**

```powershell theme={null}
$env:GEMINI_API_KEY = "sk-xxxxxxxxxxxx"
$env:GEMINI_BASE_URL = "https://api.apimart.ai/v1"
```

**macOS/Linux (Bash) :**

```bash theme={null}
export GEMINI_API_KEY="sk-xxxxxxxxxxxx"
export GEMINI_BASE_URL="https://api.apimart.ai/v1"
```

### 2.2 Variables d'environnement permanentes (recommandé)

Conserver la configuration pour que les nouveaux shells la reprennent automatiquement.

**Windows (PowerShell) :**

1. Exécuter PowerShell en tant qu'administrateur
2. Définir les variables d'environnement utilisateur :

```powershell theme={null}
[System.Environment]::SetEnvironmentVariable('GEMINI_API_KEY', 'sk-xxxxxxxxxxxx', 'User')
[System.Environment]::SetEnvironmentVariable('GEMINI_BASE_URL', 'https://api.apimart.ai/v1', 'User')
```

3. Redémarrez PowerShell ou rechargez les variables :

```powershell theme={null}
$env:GEMINI_API_KEY = [System.Environment]::GetEnvironmentVariable('GEMINI_API_KEY', 'User')
$env:GEMINI_BASE_URL = [System.Environment]::GetEnvironmentVariable('GEMINI_BASE_URL', 'User')
```

**macOS/Linux (Bash) :**

1. Modifiez le fichier rc de votre shell :

```bash theme={null}
# Bash
nano ~/.bashrc

# Zsh (par défaut sur macOS)
nano ~/.zshrc
```

2. Ajoutez :

```bash theme={null}
# APIMart Gemini CLI
export GEMINI_API_KEY="sk-xxxxxxxxxxxx"
export GEMINI_BASE_URL="https://api.apimart.ai/v1"
```

3. Rechargez :

```bash theme={null}
source ~/.bashrc   # Bash
source ~/.zshrc    # Zsh
```

### 2.3 Utiliser un fichier `.env`

Créez `.env` dans votre projet :

```bash theme={null}
# .env
GEMINI_API_KEY=sk-xxxxxxxxxxxx
GEMINI_BASE_URL=https://api.apimart.ai/v1
```

Chargez les variables avant d'exécuter Gemini :

**macOS/Linux :**

```bash theme={null}
export $(cat .env | xargs) && gemini chat
```

**Windows (PowerShell) :**

```powershell theme={null}
Get-Content .env | ForEach-Object {
    $name, $value = $_.split('=')
    Set-Content env:\$name $value
}
gemini chat
```

<Note>
  **Important :** - Remplacez `sk-xxxxxxxxxxxx` par votre vraie clé depuis la [console APIMart](https://apimart.ai/keys) - Définissez `GEMINI_BASE_URL` à `https://api.apimart.ai/v1` pour que Gemini CLI dialogue avec APIMart - Ajoutez `.env` à `.gitignore` pour ne pas committer les clés
</Note>

### 2.4 Vérifier la configuration

**macOS/Linux :**

```bash theme={null}
echo $GEMINI_API_KEY
echo $GEMINI_BASE_URL
```

**Windows (PowerShell) :**

```powershell theme={null}
echo $env:GEMINI_API_KEY
echo $env:GEMINI_BASE_URL
```

Si les valeurs semblent correctes, la configuration a réussi.

## Étape 3 : Utiliser Gemini CLI

### 3.1 Chat de base

Session interactive :

```bash theme={null}
gemini chat
```

Prompt ponctuel :

```bash theme={null}
gemini "Give a short overview of the history of artificial intelligence"
```

### 3.2 Choisir un modèle

```bash theme={null}
gemini chat --model gpt-4o
```

Ou :

```bash theme={null}
gemini "Write a Python quicksort implementation" --model claude-sonnet-4-5-20250929
```

### 3.3 Lire les prompts depuis un fichier

```bash theme={null}
gemini --input prompt.txt
```

Ou par pipe :

```bash theme={null}
cat prompt.txt | gemini
```

### 3.4 Sauvegarder la sortie dans un fichier

```bash theme={null}
gemini "Generate a React component" --output component.jsx
```

## Étape 4 : Appeler APIMart depuis votre code

### 4.1 SDK Python

```python theme={null}
import openai

# APIMart
openai.api_key = "sk-xxxxxxxxxxxx"  # Your APIMart API key
openai.api_base = "https://api.apimart.ai/v1"

response = openai.ChatCompletion.create(
    model="gemini-2.0-flash-exp",
    messages=[
        {"role": "user", "content": "Hi—please introduce yourself"}
    ]
)

print(response.choices[0].message.content)
```

### 4.2 JavaScript / TypeScript

```javascript theme={null}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "sk-xxxxxxxxxxxx",
  baseURL: "https://api.apimart.ai/v1",
});

async function main() {
  const completion = await client.chat.completions.create({
    model: "gemini-2.0-flash-exp",
    messages: [{ role: "user", content: "Hi—please introduce yourself" }],
  });

  console.log(completion.choices[0].message.content);
}

main();
```

### 4.3 cURL

```bash theme={null}
curl https://api.apimart.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-xxxxxxxxxxxx" \
  -d '{
    "model": "gemini-2.0-flash-exp",
    "messages": [
      {"role": "user", "content": "Hi—please introduce yourself"}
    ]
  }'
```

## Étape 5 : Choisir un modèle

### Modèles recommandés

APIMart prend en charge de nombreux modèles ; choisissez selon la tâche et le budget.

**Gemini**

| Nom du modèle    | ID du modèle           | Caractéristiques   | Adapté à                         |
| ---------------- | ---------------------- | ------------------ | -------------------------------- |
| Gemini 2.0 Flash | `gemini-2.0-flash-exp` | Rapide, multimodal | Réponses rapides, vision + texte |
| Gemini 2.5 Pro   | `gemini-2.5-pro`       | Capacité forte     | Problèmes difficiles, analyse    |
| Gemini 2.5 Flash | `gemini-2.5-flash`     | Très réactif       | Chat temps réel, jobs par lots   |

**GPT**

| Nom du modèle | ID du modèle  | Caractéristiques | Adapté à                        |
| ------------- | ------------- | ---------------- | ------------------------------- |
| GPT-5         | `gpt-5`       | Haut de gamme    | Raisonnement, écriture créative |
| GPT-4o        | `gpt-4o`      | Haute qualité    | Chat général, contenu           |
| GPT-4o Mini   | `gpt-4o-mini` | Économique       | Tâches simples, gros volumes    |

**Claude**

| Nom du modèle     | ID du modèle                 | Caractéristiques  | Adapté à                    |
| ----------------- | ---------------------------- | ----------------- | --------------------------- |
| Claude Sonnet 4.5 | `claude-sonnet-4-5-20250929` | Raisonnement fort | Code, logique               |
| Claude Haiku 4.5  | `claude-haiku-4-5-20251001`  | Très rapide       | Q\&R, chat à faible latence |

<Tip>
  **Choix rapides :** - 🚀 **Stack style Google :** `gemini-2.0-flash-exp`, `gemini-2.5-pro` - 💡 **Codage :** `claude-sonnet-4-5-20250929`, `gpt-5` - 💰 **Coût :** `gpt-4o-mini`, `claude-haiku-4-5-20251001` - ⚡ **Vitesse :** `gemini-2.0-flash-exp`, `gpt-4o-mini`
</Tip>

## Fonctionnalités avancées

### Multimodal (images)

Avec un modèle multimodal tel que Gemini 2.0 Flash :

```python theme={null}
response = openai.ChatCompletion.create(
    model="gemini-2.0-flash-exp",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/image.jpg"
                    }
                }
            ]
        }
    ]
)
```

### Streaming

Diffuser les tokens à mesure qu'ils arrivent :

```python theme={null}
stream = openai.ChatCompletion.create(
    model="gemini-2.0-flash-exp",
    messages=[{"role": "user", "content": "Write a short poem about spring"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end='')
```

### Ajustement des paramètres

Forme du caractère aléatoire et de la longueur :

```python theme={null}
response = openai.ChatCompletion.create(
    model="gemini-2.0-flash-exp",
    messages=[{"role": "user", "content": "Your question"}],
    temperature=0.7,        # randomness (0–2)
    max_tokens=2000,        # max output length
    top_p=0.9,              # nucleus sampling
    presence_penalty=0,     # topic diversity
    frequency_penalty=0     # repetition penalty
)
```

## FAQ

### Q1 : « Invalid API key » ou erreurs d'authentification

1. **Format de la clé**
   * Doit commencer par `sk-`
   * Pas d'espaces supplémentaires lors du collage

2. **Variables d'environnement**

   ```bash theme={null}
   # macOS / Linux
   echo $GEMINI_API_KEY
   echo $GEMINI_BASE_URL

   # Windows PowerShell
   echo $env:GEMINI_API_KEY
   echo $env:GEMINI_BASE_URL
   ```

3. **Statut de la clé**
   * Vérifiez la clé dans la [console APIMart](https://apimart.ai/keys)
   * Assurez-vous que votre compte a du solde

### Q2 : Comment vérifier la configuration de l'API ?

```python theme={null}
import openai

openai.api_key = "sk-xxxxxxxxxxxx"
openai.api_base = "https://api.apimart.ai/v1"

try:
    response = openai.ChatCompletion.create(
        model="gemini-2.0-flash-exp",
        messages=[{"role": "user", "content": "test"}],
        max_tokens=10
    )
    print("✅ API configuration OK")
    print(f"Reply: {response.choices[0].message.content}")
except Exception as e:
    print(f"❌ API configuration failed: {e}")
```

### Q3 : Quels langages sont pris en charge ?

Tout langage capable d'envoyer des requêtes HTTP fonctionne avec APIMart :

* ✅ **Python** — SDK OpenAI recommandé
* ✅ **JavaScript / TypeScript** — Node ou navigateur
* ✅ **Java** — client HTTP
* ✅ **Go** — stdlib ou bibliothèques
* ✅ **PHP** — cURL ou Guzzle
* ✅ **Ruby** — gems HTTP
* ✅ **C# / .NET** — `HttpClient`
* ✅ **Swift** — `URLSession`
* ✅ **Autres** — tout ce qui supporte HTTP

### Q4 : Où voir l'utilisation et la facturation ?

Dans la [console APIMart](https://apimart.ai/overview) :

* 📊 Statistiques d'appels en direct
* 💰 Coûts et factures
* 📈 Tendances d'utilisation
* 🔍 Journaux des requêtes
* ⚙️ Gestion des clés API

### Q5 : Erreurs API courantes

| Erreur                      | Cause probable                 | Que faire                                              |
| --------------------------- | ------------------------------ | ------------------------------------------------------ |
| `401 Unauthorized`          | Mauvaise clé ou clé révoquée   | Corriger la clé dans env / console                     |
| `429 Too Many Requests`     | Limite de débit                | Ralentir ou monter le plan                             |
| `500 Internal Server Error` | Problème temporaire du serveur | Réessayer plus tard ; contacter le support si persiste |
| `insufficient_quota`        | Solde faible                   | Recharger dans la console                              |

## Bonnes pratiques

### 1. Nouvelles tentatives et backoff

```python theme={null}
import openai
import time

def call_with_retry(max_retries=3):
    for i in range(max_retries):
        try:
            response = openai.ChatCompletion.create(
                model="gemini-2.0-flash-exp",
                messages=[{"role": "user", "content": "Your question"}]
            )
            return response
        except openai.error.RateLimitError:
            if i < max_retries - 1:
                time.sleep(2 ** i)
                continue
            raise
        except Exception as e:
            print(f"Error: {e}")
            raise

response = call_with_retry()
```

### 2. Contrôle des coûts

```python theme={null}
def choose_model(complexity):
    if complexity == "simple":
        return "gpt-4o-mini"
    elif complexity == "medium":
        return "gemini-2.0-flash-exp"
    return "gpt-5"

model = choose_model("simple")
response = openai.ChatCompletion.create(
    model=model,
    messages=[{"role": "user", "content": "Your question"}],
    max_tokens=500
)
```

### 3. Prompts système

```python theme={null}
response = openai.ChatCompletion.create(
    model="gemini-2.0-flash-exp",
    messages=[
        {
            "role": "system",
            "content": "You are an expert Python assistant who writes clear, efficient code."
        },
        {
            "role": "user",
            "content": "Implement quicksort for me"
        }
    ]
)
```

## Fonctionnalités

Avec **Google AI Studio** et **APIMart**, vous obtenez :

* 🤖 **De nombreux modèles** — GPT, Claude, Gemini et plus
* 🌍 **Compatible OpenAI** — forme de requête/réponse familière
* ⚡ **Performances** — faible latence, forte concurrence
* 💰 **Tarification claire** — paiement à l'usage
* 📊 **Observabilité** — surveillez les appels en temps réel
* 🔒 **Sécurité** — garanties orientées entreprise
* 🚀 **Intégration rapide** — appels HTTP/SDK simples
* 📚 **Documentation** — guides et exemples

## Support

* 📚 [Documentation APIMart](https://docs.apimart.ai)
* 📚 [Documentation Google AI Studio](https://ai.google.dev/docs)
* 💬 [Discord](https://discord.gg/V8zqssyZ5c)
* 🐦 [Twitter @APIMart\_](https://x.com/APIMart_)
* 📧 [zhihong@apimart.ai](mailto:zhihong@apimart.ai)

***

<Card title="Commencer avec APIMart" icon="rocket" href="https://apimart.ai">
  Créez un compte, obtenez une clé API et utilisez plusieurs modèles d'IA depuis les workflows Google AI Studio et au-delà.
</Card>