# aicentos Docs > aicentos est une plateforme d’agrégation d’API d’IA pour les développeurs et les entreprises. Une seule clé API pour OpenAI, Anthropic, Google, xAI et plus — redondance en amont avec bascule automatique, disponibilité publiée en temps réel, contrats et déploiement privé. Ce fichier rassemble les documents disponibles en français, avec une URL source pour chaque page. [Index de la documentation](https://docs.aicentos.com/fr/llms.txt) # Format natif Claude Source: https://docs.aicentos.com/fr/api/chat/claude Language: fr Chat `POST /messages` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Corps de requête `application/json` Définition des types TypeScript Utiliser le type de corps de requête dans TypeScript ## Corps de réponse ### `application/json` ### `application/json` ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X POST "https://aicentos.com/v1/messages" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "claude-sonnet-4-6", "max_tokens": 256, "messages": [ { "role": "user", "content": "Présente-toi en une phrase" } ] }' ``` ```bash { "id": "string", "type": "message", "role": "assistant", "content": [ { "type": "text", "text": "string" } ], "model": "string", "stop_reason": "end_turn", "usage": { "input_tokens": 0, "output_tokens": 0 } } ``` ```bash { "error": { "message": "Incorrect API key provided", "type": "authentication_error", "code": "invalid_api_key" } } ``` ```bash { "error": { "message": "Incorrect API key provided", "type": "authentication_error", "code": "invalid_api_key" } } ``` --- # Chat texte Gemini Source: https://docs.aicentos.com/fr/api/chat/gemini/text Language: fr Chat — format natif Gemini `POST /v1beta/models/{model}:generateContent` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Paramètres de chemin model\*string ## Corps de requête `application/json` Définition des types TypeScript Utiliser le type de corps de requête dans TypeScript ## Corps de réponse ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X POST "https://aicentos.com/v1beta/models/gemini-2.0-pro:generateContent" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "contents": [ { "role": "user", "parts": [ { "text": "Présente-toi en une phrase" } ] } ] }' ``` ```bash { "candidates": [ { "content": {}, "finishReason": "string", "index": 0 } ], "usageMetadata": { "promptTokenCount": 0, "candidatesTokenCount": 0, "totalTokenCount": 0 } } ``` --- # Format ChatCompletions Source: https://docs.aicentos.com/fr/api/chat/openai/chat-completions Language: fr Chat — format natif OpenAI `POST /chat/completions` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Corps de requête `application/json` Définition des types TypeScript Utiliser le type de corps de requête dans TypeScript ## Corps de réponse ### `application/json` ### `application/json` ### `application/json` ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X POST "https://aicentos.com/v1/chat/completions" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "gpt-4o-mini", "messages": [ { "role": "user", "content": "Présente-toi en une phrase" } ] }' ``` ```bash { "id": "chatcmpl-abc123", "object": "chat.completion", "created": 0, "model": "string", "choices": [ { "index": 0, "message": { "role": "system", "content": "string", "name": "string" }, "finish_reason": "stop" } ], "usage": { "prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0 } } ``` ```bash { "error": { "message": "Incorrect API key provided", "type": "authentication_error", "code": "invalid_api_key" } } ``` ```bash { "error": { "message": "Incorrect API key provided", "type": "authentication_error", "code": "invalid_api_key" } } ``` ```bash { "error": { "message": "Incorrect API key provided", "type": "authentication_error", "code": "invalid_api_key" } } ``` --- # Format Responses Source: https://docs.aicentos.com/fr/api/chat/openai/responses Language: fr Chat — format natif OpenAI `POST /responses` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Corps de requête `application/json` Définition des types TypeScript Utiliser le type de corps de requête dans TypeScript ## Corps de réponse ### `application/json` ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X POST "https://aicentos.com/v1/responses" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "gpt-5", "input": "Présente-toi en une phrase" }' ``` ```bash { "id": "string", "object": "response", "status": "completed", "output": [], "usage": {} } ``` ```bash { "error": { "message": "Incorrect API key provided", "type": "authentication_error", "code": "invalid_api_key" } } ``` --- # Format natif Gemini Source: https://docs.aicentos.com/fr/api/images/nano-banana/gemini Language: fr Images — Nano Banana `POST /v1beta/models/gemini-3-pro-image-preview:generateContent` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Corps de requête `application/json` Définition des types TypeScript Utiliser le type de corps de requête dans TypeScript ## Corps de réponse ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X POST "https://aicentos.com/v1beta/models/gemini-3-pro-image-preview:generateContent" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "contents": [ { "role": "user", "parts": [ { "text": "Un capybara en combinaison spatiale flottant dans l’espace" } ] } ], "generationConfig": { "responseModalities": [ "IMAGE" ] } }' ``` ```bash { "candidates": [ { "content": { "role": "string", "parts": [ { "text": "string", "inlineData": { "mimeType": "string", "data": "string" } } ] }, "finishReason": "string", "index": 0 } ], "usageMetadata": { "promptTokenCount": 0, "candidatesTokenCount": 0, "totalTokenCount": 0 }, "modelVersion": "string" } ``` --- # Modifier une image Source: https://docs.aicentos.com/fr/api/images/openai/edits Language: fr Images — format natif OpenAI `POST /images/edits` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Corps de requête `multipart/form-data` Définition des types TypeScript Utiliser le type de corps de requête dans TypeScript ## Corps de réponse ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X POST "https://aicentos.com/v1/images/edits" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -F image="[ \"string\" ]" \ -F prompt="string" ``` ```bash { "created": 0, "background": "string", "output_format": "string", "size": "string", "data": [ { "url": "string", "b64_json": "string" } ], "usage": { "input_tokens": 0, "output_tokens": 0, "total_tokens": 0 } } ``` --- # Générer une image Source: https://docs.aicentos.com/fr/api/images/openai/generations Language: fr Images — format natif OpenAI `POST /images/generations` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Corps de requête `application/json` Définition des types TypeScript Utiliser le type de corps de requête dans TypeScript ## Corps de réponse ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X POST "https://aicentos.com/v1/images/generations" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "gpt-image-2", "prompt": "A futuristic city skyline at sunset, neon lights, cinematic", "size": "1024x1024", "quality": "hd" }' ``` ```bash { "created": 0, "background": "string", "output_format": "string", "quality": "string", "size": "string", "data": [ { "url": "string", "b64_json": "string", "revised_prompt": "string" } ], "usage": { "input_tokens": 0, "output_tokens": 0, "total_tokens": 0, "input_tokens_details": { "text_tokens": 0, "image_tokens": 0 }, "output_tokens_details": { "text_tokens": 0, "image_tokens": 0 } } } ``` --- # Format natif Gemini Source: https://docs.aicentos.com/fr/api/models/gemini Language: fr Modèles `GET /v1beta/models` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Corps de réponse ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X GET "https://aicentos.com/v1beta/models" \ -H "Authorization: Bearer $AICENTOS_API_KEY" ``` ```bash { "models": [ { "name": "models/gemini-2.0-pro", "displayName": "string", "description": "string", "inputTokenLimit": 0, "outputTokenLimit": 0, "supportedGenerationMethods": [ "string" ] } ] } ``` --- # Format natif OpenAI Source: https://docs.aicentos.com/fr/api/models/openai Language: fr Modèles `GET /models` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Corps de réponse ### `application/json` ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X GET "https://aicentos.com/v1/models" \ -H "Authorization: Bearer $AICENTOS_API_KEY" ``` ```bash { "object": "list", "data": [ { "id": "gpt-4o-mini", "object": "model", "created": 1715000000, "owned_by": "openai" } ] } ``` ```bash { "error": { "message": "Incorrect API key provided", "type": "authentication_error", "code": "invalid_api_key" } } ``` --- # Dreamina · Créer une vidéo Source: https://docs.aicentos.com/fr/api/videos/dreamina/create Language: fr > Soumet une tâche de génération vidéo Dreamina et renvoie l’identifiant de tâche ainsi que le statut initial Vidéos — format Dreamina `POST /videos` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Corps de requête `application/json` Définition des types TypeScript Utiliser le type de corps de requête dans TypeScript ## Corps de réponse ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X POST "https://aicentos.com/v1/videos" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "veo-3.1-fast-generate-preview", "prompt": "un DJ en train de mixer", "size": "1920x1080", "seconds": "8" }' ``` ```bash { "id": "string", "task_id": "string", "status": "queued" } ``` --- # Dreamina · Obtenir le statut d’une tâche vidéo Source: https://docs.aicentos.com/fr/api/videos/dreamina/get-task Language: fr > Interroge la progression et le résultat d’une génération vidéo Dreamina à partir de l’identifiant de tâche Vidéos — format Dreamina `GET /videos/{task_id}` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Paramètres de chemin task\_id\*string ## Corps de réponse ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X GET "https://aicentos.com/v1/videos/string" \ -H "Authorization: Bearer $AICENTOS_API_KEY" ``` ```bash { "id": "string", "task_id": "string", "status": "queued", "progress": 0, "url": "string", "error": "string" } ``` --- # Sora · Créer une vidéo Source: https://docs.aicentos.com/fr/api/videos/sora/create Language: fr > Soumet une tâche de génération vidéo Sora, renvoie l’identifiant de tâche et le statut initial ; la progression s’interroge ensuite avec cet identifiant Vidéos — Veo (compatible OpenAI) `POST /videos` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Corps de requête `application/json` Définition des types TypeScript Utiliser le type de corps de requête dans TypeScript ## Corps de réponse ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X POST "https://aicentos.com/v1/videos" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "veo-3.1-fast-generate-preview", "prompt": "un DJ en train de mixer", "size": "1920x1080", "seconds": "8" }' ``` ```bash { "id": "string", "task_id": "string", "status": "queued" } ``` --- # Sora · Obtenir le contenu vidéo Source: https://docs.aicentos.com/fr/api/videos/sora/get-content Language: fr > Une fois la tâche terminée, récupère l’adresse du fichier vidéo généré par Sora à partir de l’identifiant de tâche Vidéos — Veo (compatible OpenAI) `GET /videos/{task_id}/content` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Paramètres de chemin task\_id\*string ## Corps de réponse ### ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X GET "https://aicentos.com/v1/videos/string/content" \ -H "Authorization: Bearer $AICENTOS_API_KEY" ``` ```bash { "url": "string", "expires_at": 0 } ``` --- # Sora · Obtenir le statut d’une tâche vidéo Source: https://docs.aicentos.com/fr/api/videos/sora/get-task Language: fr > Interroge la progression d’une génération vidéo Sora à partir de l’identifiant de tâche, avec statut et cause d’échec Vidéos — Veo (compatible OpenAI) `GET /videos/{task_id}` ## Authentification Stockez votre clé API dans `AICENTOS_API_KEY` ; les exemples shell utilisent sa valeur dans l’en-tête `Authorization: Bearer`. Clé API obtenue dans la console, section « Gestion des jetons » Emplacement : `header` ## Paramètres de chemin task\_id\*string ## Corps de réponse ### `application/json` ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" curl -X GET "https://aicentos.com/v1/videos/string" \ -H "Authorization: Bearer $AICENTOS_API_KEY" ``` ```bash { "id": "string", "task_id": "string", "status": "queued", "progress": 0, "url": "string", "error": "string" } ``` --- # Erreurs Source: https://docs.aicentos.com/fr/billing/errors Language: fr > Codes de statut HTTP, structure des réponses d’erreur, erreurs courantes et solutions aicentos reprend intégralement le **format de réponse d’erreur d’OpenAI**. Quand un SDK lève une erreur, il suffit d’intercepter l’exception correspondante. ## Structure d’une réponse d’erreur Toutes les réponses d’erreur suivent ce format : ```bash { "error": { "message": "Votre clé API n’a pas accès à gpt-5", "type": "permission_denied", "code": "model_not_allowed", "param": "model" } } ``` | Champ | Signification | | --------- | ---------------------------------------------------- | | `message` | Description de l’erreur, lisible par un humain | | `type` | Catégorie d’erreur (voir tableau ci-dessous) | | `code` | Code d’erreur détaillé (pour la logique applicative) | | `param` | Nom du champ en erreur (le cas échéant) | ## Codes de statut HTTP en bref | Code | Type | Causes courantes | | ----- | ------------------------ | ------------------------------------------------------------------------------- | | `400` | `invalid_request_error` | corps de requête mal formé, paramètre invalide, nom de `model` mal orthographié | | `401` | `authentication_error` | clé API absente / erronée / révoquée | | `402` | `insufficient_quota` | solde insuffisant | | `403` | `permission_denied` | clé désactivée, modèle non autorisé, IP hors liste blanche | | `404` | `not_found` | chemin d’endpoint erroné, ID de modèle erroné | | `408` | `request_timeout` | délai d’attente amont (généralement > 60 s sans réponse) | | `413` | `payload_too_large` | corps de requête trop volumineux (image, fichier) | | `415` | `unsupported_media_type` | Content-Type incorrect | | `422` | `invalid_request_error` | corps de requête analysable mais sémantiquement incorrect | | `429` | `rate_limit_exceeded` | limite de débit déclenchée ; réduisez la fréquence puis réessayez | | `500` | `server_error` | erreur interne de la plateforme (rare) | | `502` | `bad_gateway` | service amont en anomalie | | `503` | `service_unavailable` | amont surchargé ; réessayez plus tard | | `504` | `gateway_timeout` | délai dépassé côté amont | ## Erreurs courantes et solutions ### 401 — Invalid API key ```bash { "error": { "message": "Incorrect API key provided", "type": "authentication_error" } } ``` **Liste de vérification** : * l’en-tête `Authorization` respecte bien le format `Bearer sk-xxx` (attention à l’espace) * la clé copiée depuis la console n’embarque pas d’espace ni de saut de ligne * la clé n’est ni supprimée, ni désactivée, ni expirée * une clé de test n’a pas été poussée en production ### 402 — Insufficient quota ```bash { "error": { "message": "Insufficient quota", "type": "insufficient_quota" } } ``` Rechargez → console, « Gestion du portefeuille ». Activez l’[alerte de solde](https://docs.aicentos.com/fr/billing/pricing#alerte-de-solde) pour éviter que cela se reproduise. ### 403 — Model not allowed ```bash { "error": { "message": "Model gpt-5 not allowed for this key", "code": "model_not_allowed" } } ``` À la création du jeton, une liste blanche « **Modèles autorisés** » a été cochée et le `model` demandé n’en fait pas partie. Modifiez les réglages du jeton ou changez de clé. ### 404 — Model not found ```bash { "error": { "message": "The model 'gpt-4-turbo-2024-04-09' does not exist", "code": "model_not_found" } } ``` ID de modèle mal orthographié ou retiré. Vérifiez les ID actuellement disponibles dans le [catalogue des modèles](https://aicentos.com/pricing). ### 429 — Rate limit exceeded L’en-tête `Retry-After` indique au bout de combien de secondes réessayer. Réduisez la concurrence et la fréquence des requêtes pour revenir à la normale. ### 500 / 502 / 503 — Erreur de service Généralement une instabilité amont. **2 à 3 tentatives automatiques** suffisent souvent. Si cela dure plus de 5 minutes : * consultez la [page de statut](https://status.aicentos.com) (si disponible) * contactez le support ### 408 / 504 — Délai dépassé Aucune réponse au bout de 60 s. Causes fréquentes : * prompt trop long : la « réflexion » du modèle dépasse le délai imparti * sortie en streaming non activée (ajoutez `stream: true` pour les réponses longues) **Solutions** : * raccourcissez le prompt * activez le streaming : `{ "model": "...", "messages": [...], "stream": true }` * passez à un modèle plus rapide (par exemple de `gpt-4o` à `gpt-4o-mini`) ## Exemple de gestion des erreurs en SDK ```bash export AICENTOS_API_KEY="sk-your-aicentos-api-key" ``` ### Python ```python import os from openai import OpenAI, APIError, RateLimitError, AuthenticationError client = OpenAI(api_key=os.environ["AICENTOS_API_KEY"], base_url="https://aicentos.com/v1") try: resp = client.chat.completions.create( model="gpt-4o-mini", messages=[{"role": "user", "content": "hi"}], ) except AuthenticationError: print("Clé incorrecte") except RateLimitError as e: print(f"Limite de débit atteinte, nouvelle tentative dans {e.response.headers.get('Retry-After')} s") except APIError as e: print(f"Autre erreur API : {e.status_code} {e.message}") ``` ### Node.js ```js import OpenAI, { APIError } from 'openai'; const client = new OpenAI({ apiKey: process.env.AICENTOS_API_KEY, baseURL: 'https://aicentos.com/v1', }); try { const resp = await client.chat.completions.create({ ... }); } catch (err) { if (err instanceof APIError) { console.log(err.status, err.code, err.message); } } ``` ## Réessais et repli | Type d’erreur | Traitement recommandé | | ------------------------------------- | ------------------------------------------------------------------------ | | `400` / `401` / `402` / `403` / `404` | **pas de réessai** : erreur de code / de configuration, corrigez d’abord | | `429` | réessayez selon `Retry-After`, avec backoff exponentiel | | `500` / `502` / `503` / `504` / `408` | réessayez immédiatement 1 à 3 fois, espacées de 1 à 5 s | Les SDK officiels OpenAI embarquent par défaut une politique de réessai raisonnable ; **en production, passez par le SDK plutôt que par vos propres appels fetch**. --- # Modèles pris en charge Source: https://docs.aicentos.com/fr/billing/models-list Language: fr > Catalogue complet des modèles de Google / xAI / OpenAI / Anthropic / Alibaba / DeepSeek / Zhipu / Moonshot / MiniMax aicentos intègre les modèles d’OpenAI, Anthropic, Google, xAI, Alibaba Qwen, DeepSeek, Zhipu, Moonshot, MiniMax et d’autres grands fournisseurs, couvrant chat, raisonnement, code, image, vidéo, embeddings, etc. ## Fournisseurs et modèles emblématiques Les fournisseurs et les modèles en vente évoluent au rythme des ajouts et retraits en amont ; les chiffres réels font foi dans la place de marché en direct. Le tableau ci-dessous ne liste que des modèles représentatifs : | Fournisseur | Modèles représentatifs | | ------------ | ------------------------------------------------------- | | Google | `gemini-3.8-flash`, `gemini-3.1-pro`, `nano-banana-2` | | xAI | `grok-4.7`, `grok-4.6`, `grok-build-0.1` | | OpenAI | `gpt-5.6-sol`, `gpt-6-astra`, `gpt-image-2.5` | | Anthropic | `claude-opus-4-8`, `claude-opus-4-7`, `claude-sonnet-5` | | Alibaba Qwen | `qwen3.8-max`, `qwen3-coder-plus` | | DeepSeek | `deepseek-v4-pro`, `deepseek-v4.1-flash` | | Zhipu | `glm-5.3`, `glm-5.2` | | Moonshot | `kimi-k3`, `kimi-k2.6` | | MiniMax | `minimax-m3`, `minimax-m2.7` | La liste des modèles en temps réel et leur tarification font foi dans la console : Catalogue des modèles Le catalogue se filtre par **fournisseur**, **groupe de jetons disponibles**, **type de facturation** et **étiquette**, avec bascule entre vue en cartes et vue en tableau. [👉 Ouvrir la page des tarifs des modèles](https://aicentos.com/pricing) ## Que renseigner dans le champ model Le champ `model` reçoit l’**identifiant du modèle** (copiable en un clic sur chaque carte de la page des tarifs). Exemples courants : | Modèle souhaité | Valeur du champ `model` | | -------------------------- | ----------------------- | | Claude Opus le plus récent | `claude-opus-4-8` | | Claude Sonnet | `claude-sonnet-5` | | Claude Haiku | `claude-haiku-4-5` | | GPT haut de gamme | `gpt-5.6-sol` | | GPT image | `gpt-image-2.5` | | Gemini Pro | `gemini-3.1-pro` | | Gemini Flash | `gemini-3.8-flash` | | Grok | `grok-4.7` | | DeepSeek | `deepseek-v4-pro` | | Qwen | `qwen3.8-max` | | Zhipu GLM | `glm-5.3` | | Kimi | `kimi-k3` | | MiniMax | `minimax-m3` | ## Disponibilité des modèles en temps réel Les modèles amont subissent de temps à autre des maintenances ou des limitations de débit. Avant d’intégrer, consultez le **tableau de santé des modèles** pour vérifier le taux de disponibilité et la latence récents du modèle visé : [👉 Voir la supervision des statuts des modèles](https://docs.aicentos.com/status) À chaque cycle de contrôle, le panneau enregistre pour chaque modèle la disponibilité 1 h / 24 h / 7 j, la latence de réponse et le PING des endpoints ; les échecs consécutifs sont marqués automatiquement. ## Restreindre les modèles disponibles Pour qu’une clé n’appelle que certains modèles, cochez « **Modèles autorisés** » à la création de la **clé API** afin de constituer une liste blanche. Par exemple, une clé de démo publique n’ouvre que `claude-haiku-4-5` et `gemini-3.8-flash`. ## Le modèle recherché n’apparaît pas ? Nous adaptons les nouveaux modèles au fur et à mesure de leurs publications par les fournisseurs. Si le modèle dont vous avez besoin n’est pas encore disponible, dites-le-nous via les coordonnées de la console ou suivez les annonces sur [X / Twitter](https://x.com/aicentos). --- # Tarifs officiels de référence Source: https://docs.aicentos.com/fr/billing/official-pricing Language: fr > Tous les modèles intégrés par aicentos, avec les tarifs API officiels d’OpenAI / Anthropic / Google Le tableau ci-dessous recense **tous les modèles intégrés par aicentos**, aux **tarifs API officiels** publiés sur les sites des fournisseurs (en date de mai 2026). * Unité : **dollars US / 1M tokens** (image, voix et vidéo sont indiqués à part). * « Lecture cache » désigne le prix d’entrée en cas de hit du cache ; Anthropic facture en plus une écriture de cache (1,25× de l’entrée standard). * Les variantes `-thinking` / `-nothinking` / versions datées / `-high/-low/-medium` d’un même modèle de base sont facturées au **même tarif officiel** que le modèle de base et sont regroupées ici. > Les prix réellement facturés via aicentos sont bien inférieurs aux tarifs officiels ; seul l’affichage en temps réel sur [la page des tarifs aicentos](https://docs.aicentos.com/fr/billing/pricing) et [le catalogue des modèles](https://aicentos.com/pricing) fait foi. ## OpenAI ### Série GPT-5.x | Modèle | Entrée officielle | Sortie officielle | Lecture cache | | ---------------------------------------------------------------------- | ----------------- | ----------------- | ------------- | | `gpt-5`, `gpt-5-codex`, `gpt-5-chat-latest` | $1.25 | $10.00 | $0.125 | | `gpt-5-mini` | $0.25 | $2.00 | $0.025 | | `gpt-5-nano` | $0.05 | $0.40 | $0.005 | | `gpt-5-pro` | $15.00 | $120.00 | — | | `gpt-5.1`, `gpt-5.1-codex`, `gpt-5.1-codex-max`, `gpt-5.1-chat-latest` | $1.25 | $10.00 | $0.125 | | `gpt-5.1-codex-mini` | $0.25 | $2.00 | $0.025 | | `gpt-5.2`, `gpt-5.2-codex`, `gpt-5.2-chat-latest` | $1.75 | $14.00 | $0.175 | | `gpt-5.2-pro` | $21.00 | $168.00 | — | | `gpt-5.3-codex`, `gpt-5.3-chat-latest` | $1.75 | $14.00 | $0.175 | | `gpt-5.4` | $2.50 | $15.00 | $0.25 | | `gpt-5.4-mini` | $0.75 | $4.50 | — | | `gpt-5.4-nano` | $0.20 | $1.25 | — | | `gpt-5.4-pro` | $30.00 | $180.00 | — | | `gpt-5.5` | $5.00 | $30.00 | $0.50 | > Le contexte de GPT-5.x est d’environ 400K (supérieur pour les modèles phares 5.4 / 5.5). `-codex` est la version dédiée au code, `-chat` la version conversation, `-pro` la version haute puissance ; tarifs officiels identiques au tableau ci-dessus. ### Série GPT-4o | Modèle | Entrée officielle | Sortie officielle | Lecture cache | | -------------------------------------------------- | ----------------- | ----------------- | ------------- | | `gpt-4o`, `gpt-4o-2024-08-06`, `gpt-4o-2024-11-20` | $2.50 | $10.00 | $1.25 | | `gpt-4o-2024-05-13` | $5.00 | $15.00 | — | | `chatgpt-4o-latest` | $5.00 | $15.00 | — | | `gpt-4o-mini`, `gpt-4o-mini-2024-07-18` | $0.15 | $0.60 | $0.075 | | `gpt-4o-search-preview` | $2.50 | $10.00 | — | | `gpt-4o-mini-search-preview` | $0.15 | $0.60 | — | > Contexte 128K. `-search-preview` facture en plus la recherche à hauteur de $10 / 1000 recherches. ### Série GPT-4.1 | Modèle | Entrée officielle | Sortie officielle | Lecture cache | Contexte | | ----------------------------------------- | ----------------- | ----------------- | ------------- | -------- | | `gpt-4.1`, `gpt-4.1-2025-04-14` | $2.00 | $8.00 | $0.50 | 1M | | `gpt-4.1-mini`, `gpt-4.1-mini-2025-04-14` | $0.40 | $1.60 | $0.10 | 1M | | `gpt-4.1-nano`, `gpt-4.1-nano-2025-04-14` | $0.10 | $0.40 | $0.025 | 1M | ### GPT-4 / GPT-3.5 (anciennes versions) | Modèle | Entrée officielle | Sortie officielle | Contexte | | --------------------------------------------------------------------------------------------- | ----------------- | ----------------- | -------- | | `gpt-4.5-preview`, `gpt-4.5-preview-2025-02-27` | $75.00 | $150.00 | 128K | | `gpt-4-turbo-2024-04-09`, `gpt-4-turbo-preview`, `gpt-4-0125-preview`, `gpt-4-vision-preview` | $10.00 | $30.00 | 128K | | `gpt-4-0613` | $30.00 | $60.00 | 8K | | `gpt-4-32k-0613` | $60.00 | $120.00 | 32K | | `gpt-3.5-turbo`, `gpt-3.5-turbo-0125` | $0.50 | $1.50 | 16K | | `gpt-3.5-turbo-1106` | $1.00 | $2.00 | 16K | | `gpt-3.5-turbo-instruct` | $1.50 | $2.00 | 4K | | `gpt-3.5-turbo-16k`, `gpt-3.5-turbo-16k-0613` | $3.00 | $4.00 | 16K | | `gpt-3.5-turbo-0613` | $1.50 | $2.00 | 4K | | `babbage-002` | $0.40 | $0.40 | 16K | | `davinci-002` | $2.00 | $2.00 | 16K | > `gpt-4.5-preview` est marqué déprécié par OpenAI ; prix conservés à titre de référence historique. ### Modèles de raisonnement série o | Modèle | Entrée officielle | Sortie officielle | Lecture cache | Contexte | | --------------------------------------------------------------- | ----------------- | ----------------- | ------------- | -------- | | `o1`, `o1-2024-12-17`, `o1-preview`, `o1-preview-2024-09-12` | $15.00 | $60.00 | $7.50 | 200K | | `o1-mini`, `o1-mini-2024-09-12` | $1.10 | $4.40 | $0.55 | 128K | | `o1-pro`, `o1-pro-2025-03-19` | $150.00 | $600.00 | — | 200K | | `o3` | $2.00 | $8.00 | $0.50 | 200K | | `o3-pro`, `o3-pro-2025-06-10` | $20.00 | $80.00 | — | 200K | | `o3-mini`, `o3-mini-2025-01-31` (avec `-high`/`-low`/`-medium`) | $1.10 | $4.40 | $0.55 | 200K | | `o3-deep-research` | $10.00 | $40.00 | $2.50 | 200K | | `o4-mini` | $1.10 | $4.40 | $0.275 | 200K | | `o4-mini-deep-research`, `o4-mini-deep-research-2025-06-26` | $2.00 | $8.00 | $0.50 | 200K | ### Image / voix / temps réel | Modèle | Tarif officiel | | --------------------------------------------------- | --------------------------------------------------------------------- | | `gpt-image-1` | entrée texte $5 / entrée image $10 / sortie image $40 (par 1M tokens) | | `gpt-image-1.5` | entrée texte $5 / sortie image environ $30 (par 1M tokens) | | `gpt-image-2` | non publié officiellement ; nous contacter pour un devis | | `dall-e-3` | $0.040 / image (1024×1024 standard), $0.080 / image (HD) | | `dall-e-2` | $0.016 \~ $0.020 / image | | `gpt-4o-realtime-preview` (et versions datées) | texte $5 / $20, entrée audio $40 / sortie audio $80 | | `gpt-4o-mini-realtime-preview` (et versions datées) | texte $0.60 / $2.40, entrée audio $10 / sortie $20 | | `gpt-realtime-2`, `gpt-realtime-2025-08-28` | texte $4 / $16 + audio facturé séparément | | `gpt-4o-audio-preview` (et versions datées) | texte $2.50 / $10, entrée audio $40 / sortie $80 | | `gpt-4o-mini-audio-preview` | texte $0.15 / $0.60, entrée audio $10 / sortie $20 | | `gpt-4o-mini-tts` | environ $0.015 / minute | ## Anthropic Claude | Modèle | Entrée officielle | Sortie officielle | Écriture cache (5m) | Lecture cache | Contexte | | ------------------------------------------------- | ----------------- | ----------------- | ------------------- | ------------- | -------- | | `claude-opus-4-7`, `claude-opus-4-7-thinking` | $5.00 | $25.00 | $6.25 | $0.50 | 1M | | `claude-opus-4-6`, `claude-opus-4-6-thinking` | $5.00 | $25.00 | $6.25 | $0.50 | 1M | | `claude-opus-4-5-20251101` (et `-thinking`) | $5.00 | $25.00 | $6.25 | $0.50 | 200K | | `claude-opus-4-1-20250805` (et `-thinking`) | $15.00 | $75.00 | $18.75 | $1.50 | 200K | | `claude-opus-4-20250514` | $15.00 | $75.00 | $18.75 | $1.50 | 200K | | `claude-sonnet-4-6`, `claude-sonnet-4-6-thinking` | $3.00 | $15.00 | $3.75 | $0.30 | 1M | | `claude-sonnet-4-5-20250929` (et `-thinking`) | $3.00 | $15.00 | $3.75 | $0.30 | 1M | | `claude-sonnet-4-20250514` (et `-thinking`) | $3.00 | $15.00 | $3.75 | $0.30 | 200K | | `claude-haiku-4-5-20251001` (et `-thinking`) | $1.00 | $5.00 | $1.25 | $0.10 | 200K | > La lecture cache chez Anthropic vaut uniformément **0,1×** du prix d’entrée standard (90 % moins cher en cas de hit) ; l’écriture de cache coûte 1,25× (5 minutes) ou 2× (1 heure). Opus 4 / Sonnet 4 sont officiellement marqués dépréciés. Opus 4.7 utilise un nouveau tokenizer : un même texte peut consommer environ 35 % de tokens en plus. ## Google Gemini | Modèle | Entrée officielle | Sortie officielle | Lecture cache | Contexte | | ---------------------------------------------------------------------- | ----------------------------------------------------- | ----------------- | --------------- | -------- | | `gemini-3.5-flash` | $1.50 | $9.00 | $0.15 | 1M | | `gemini-3.1-pro-preview` (et `-customtools`/`-high`/`-low`/`-medium`) | $2.00 / $4.00\* | $12.00 / $18.00\* | $0.20 \~ $0.40 | 1M | | `gemini-3.1-flash-lite`, `gemini-3.1-flash-lite-preview` | $0.25 | $1.50 | $0.025 | 1M | | `gemini-3-pro-preview` (et `-thinking`) | $2.00 / $4.00\* | $12.00 / $18.00\* | $0.20 \~ $0.40 | 1M | | `gemini-3-flash-preview` (et `-thinking`) | $0.50 | $3.00 | $0.065 | 1M | | `gemini-2.5-pro` (et `-thinking`/`-nothinking`) | $1.25 / $2.50\* | $10.00 / $15.00\* | $0.125 \~ $0.25 | 1M | | `gemini-2.5-flash` (et `-thinking`/`-nothinking`) | $0.30 | $2.50 | $0.03 | 1M | | `gemini-2.5-flash-lite` | $0.10 | $0.40 | $0.01 | 1M | | `gemini-flash-latest`, `gemini-pro-latest`, `gemini-flash-lite-latest` | aligné sur la gamme Flash / Pro / Flash-Lite actuelle | | | 1M | | `gemini-embedding-001` | $0.15 | — | — | — | | `gemini-embedding-2-preview` | $0.20 | — | — | — | > \*La série Gemini Pro est facturée en deux paliers selon la longueur du prompt : ≤200K tokens au prix bas, >200K tokens au prix élevé. ### Image / voix / vidéo | Modèle | Tarif officiel | | -------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | | `gemini-2.5-flash-image` (Nano Banana) | entrée $0.30, sortie image environ $30 / 1M tokens (environ $0.039 / image) | | `gemini-3-pro-image-preview`, `gemini-3.1-flash-image-preview` | facturé au token image, environ $0.04 \~ $0.13 / image | | `gemini-2.5-flash-preview-tts`, `gemini-2.5-pro-preview-tts`, `gemini-3.1-flash-tts-preview` | synthèse vocale, facturée au token audio | | `veo-3.0-generate-001`, `veo-3.1-generate-preview` | $0.40 / seconde | | `veo-3.0-fast-generate-001`, `veo-3.1-fast-generate-preview` | $0.15 / seconde | # Les tarifs ci-dessus sont les prix officiels des fournisseurs ; via aicentos, le prix est plus de 10 fois inférieur. **Une seule clé API pour accéder à tous ces modèles.**[S’inscrire maintenant →](https://aicentos.com/) ｜ [Voir les prix aicentos en temps réel →](https://docs.aicentos.com/fr/billing/pricing) --- # Facturation Source: https://docs.aicentos.com/fr/billing/pricing Language: fr > Recharge et facturation à l’usage — recharge Alipay, tarification au token, consultation du solde et de l’usage aicentos fonctionne en **prépaiement + facturation à l’usage**. Les recharges alimentent le solde du portefeuille et chaque requête est débitée de sa consommation réelle. Le solde est libellé en **yuan (¥)**. Toute nouvelle inscription reçoit **¥1** de crédit d’essai : le premier appel passe sans aucune recharge. ## Recharger Console → **Portefeuille** → « **Ajouter des fonds** » : Portefeuille ### Paliers de recharge **Dès ¥100 de recharge, une remise s’applique et le montant payé est inférieur au montant rechargé** : | Montant rechargé | Remise | Montant payé | | -------------------- | ------- | ------------ | | ¥1 / ¥10 / ¥20 / ¥50 | aucune | prix normal | | ¥100 | 1 % OFF | ¥99 | | ¥500 | 2 % OFF | ¥490 | | ¥1,000 | 3 % OFF | ¥970 | | ¥10,000 | 5 % OFF | ¥9,500 | La remise se reflète directement sur le paiement : rechargez ¥500, payez ¥490, soit ¥10 d’économie. Un montant personnalisé est aussi possible, tout comme l’échange de crédit via un code de recharge. Paliers de recharge ### Modes de paiement Modes de paiement * **Alipay** : paiement par QR code, crédité rapidement * Un **code de recharge** permet aussi d’obtenir du crédit * Les autres canaux de paiement sont ceux affichés sur la page du portefeuille ### Validité du crédit **Le solde n’expire jamais** : rechargez sans crainte, même en cas de consommation lente. ## Facturation à l’usage Chaque requête API est débitée selon le **nombre de tokens réellement consommés** : ```bash Coût = (tokens d’entrée × prix d’entrée + tokens de sortie × prix de sortie) × multiplicateur du groupe ``` * Chaque modèle a ses propres prix d’entrée / sortie, généralement exprimés **per 1M tokens** * Le **multiplicateur du groupe** dépend du groupe auquel appartient la clé ; il varie d’un groupe à l’autre * Les prix et multiplicateurs exacts sont ceux affichés en temps réel sur [la page des tarifs des modèles](https://aicentos.com/pricing) ### Modèles facturés à l’appel Les modèles multimédias (image, vidéo, etc.) peuvent être facturés **à l’appel** ou **à l’image** plutôt qu’au token ; le détail fait foi sur la page des tarifs des modèles. ## Consulter le solde / la consommation Dans la colonne de gauche de la console, « **Portefeuille** » affiche le solde et l’usage total : | Indicateur | Signification | | ---------------- | ---------------------------- | | **Solde actuel** | Crédit restant sur le compte | | **Usage total** | Crédit cumulé consommé | | **Requêtes API** | Nombre cumulé de requêtes | Le détail plus fin se trouve dans « **Journaux d’usage** » : filtres par période, modèle ou clé, avec le nombre de tokens et le montant débité de chaque requête. « **Tableau de bord** » fournit les tendances d’appel et les statistiques de quota par modèle. ## Alerte de solde Console → **Profil** → réglages de notification : définissez un seuil d’alerte de solde. Un avertissement part automatiquement quand le solde passe sous le seuil, pour éviter qu’une activité ne s’interrompe faute de crédit. Les seuils et canaux de notification proposés sont ceux affichés dans la console. ## Remboursements et factures * Le solde **ne donne pas lieu à un remboursement en argent** * Les débits anormaux / appels accidentels peuvent être compensés en crédit après vérification par le support * Le solde des comptes inactifs de longue date **n’expire pas** * Factures : disponibles pour les clients entreprise ayant signé un contrat ; le type de facture et la procédure sont confirmés lors des échanges commerciaux ## Équipe / quota partagé Pour attribuer du crédit aux membres de l’équipe : * créez une clé dédiée pour chaque membre dans « **Clés API** » * fixez à chaque clé un **plafond de quota** propre * limitez au besoin les modèles appelables via « **Modèles autorisés** » * auditez la consommation par clé dans « **Journaux d’usage** » ## Parrainage Console → **Portefeuille** → **Programme de parrainage** : invitez des amis à s’inscrire et chacun reçoit une récompense. Les inscrits via votre lien de parrainage exclusif sont rattachés à votre compte ; les récompenses cumulées sont transférables à tout moment vers le solde. Les taux de récompense exacts sont ceux indiqués en temps réel sur la page du portefeuille. ## Prochaines étapes * [Démarrage rapide](https://docs.aicentos.com/fr/quickstart) — trois étapes vers le premier appel * [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list) — consulter le catalogue des modèles * [Gestion des erreurs](https://docs.aicentos.com/fr/billing/errors) — diagnostiquer les erreurs de solde insuffisant, etc. --- # Amp Source: https://docs.aicentos.com/fr/clients/amp Language: fr > Utiliser aicentos dans Amp : remplacer l'adresse du back-end via le fichier de configuration Amp est l'agent de codage de Sourcegraph ; la CLI et l'extension IDE partagent le même compte et les mêmes réglages. Il n'expose pas de champ habituel « Base URL compatible OpenAI » : c'est la clé de configuration `amp.url` qui pointe le back-end entier vers un point d'accès personnalisé, les identifiants étant stockés à part dans un fichier de secrets. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour Amp (nommez-la par exemple `amp-cli`, pour suivre plus facilement sa consommation) : * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger en cas de solde insuffisant : [https://aicentos.com/wallet](https://aicentos.com/wallet) ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | API Key | La clé créée dans la console | | Base URL | `https://aicentos.com/v1` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration Les réglages d'Amp portent tous le préfixe `amp.` ; le fichier de configuration utilisateur se trouve à : * macOS / Linux : `~/.config/amp/settings.json` * Windows : `%USERPROFILE%\.config\amp\settings.json` Créez d'abord les répertoires, puis écrivez l'adresse du back-end : ```bash mkdir -p ~/.config/amp ~/.local/share/amp ``` ```json { "amp.url": "https://aicentos.com/v1" } ``` L'API Key ne s'écrit pas dans ce fichier, mais dans un fichier de secrets distinct, sous la clé `apiKey@` : ```json { "apiKey@https://aicentos.com/v1": "sk-votre-clé-API" } ``` Une fois la configuration en place, `amp login` n'a plus besoin d'être exécuté : les requêtes passent directement par le point d'accès que vous avez indiqué. Si vous vous étiez déjà connecté, il est conseillé de faire un `amp logout` puis de redémarrer `amp`, pour éviter qu'un état de connexion résiduel ne prenne le pas sur la configuration. Vous pouvez aussi passer temporairement par des variables d'environnement, pratique pour une première vérification ponctuelle : ```bash export AMP_URL="https://aicentos.com/v1" export AMP_API_KEY="sk-votre-clé-API" ``` **Remarque :** dès que ces deux variables sont définies, Amp passe la procédure de connexion et elles priment sur le fichier de configuration. ## Test Commencez par une requête légère pour vérifier que le point d'accès a bien basculé : ```bash amp -x "Réponds en une phrase : combien font 1+1 ?" ``` Une réponse normale confirme que la configuration est active. En cas de 401, la clé du fichier de secrets ne correspond sans doute pas exactement à `amp.url` (y compris la présence ou non du `/v1` final). ## Remarques * Le protocole du back-end d'Amp est sa propre interface de gestion, pas un protocole générique compatible OpenAI : `amp.url` doit donc pointer vers un point d'accès qui propose aussi une interface de style Anthropic Messages (`/v1/messages`). * aicentos propose une interface au format Claude natif (voir [Format Claude natif](https://docs.aicentos.com/fr/api/chat/claude)) et une interface compatible OpenAI (voir [Chat Completions](https://docs.aicentos.com/fr/api/chat/openai/chat-completions)) ; Amp passe par la première. * Amp demande des identifiants de modèles fixes ; si le point d'accès n'a pas de modèle du même nom, une replanification ou une erreur survient. Le cas échéant, vérifiez les noms des modèles dans la « place de marché des modèles » de la console. * Les réglages de l'extension IDE (VS Code / Cursor / Windsurf) se gèrent séparément de la CLI : l'Amp URL et l'Amp API Key y sont à renseigner indépendamment. * Le `.amp/settings.json` du répertoire de travail prend le pas sur les réglages utilisateur ; en cas de dépannage, vérifiez d'abord qu'aucun fichier de même nom n'existe dans le répertoire courant. ## Liens utiles * Documentation officielle des réglages : [https://ampcode.com/docs/cli/settings](https://ampcode.com/docs/cli/settings) --- # Antigravity CLI Source: https://docs.aicentos.com/fr/clients/antigravity-cli Language: fr > Utiliser aicentos dans Antigravity CLI : connexion via le mode clé API Antigravity CLI est l'outil en ligne de commande de Google. Il prend en charge, via le mode clé API, la connexion à des services compatibles avec l'API Gemini. Ce document explique comment configurer Antigravity CLI pour utiliser un point d'accès API personnalisé. ## Installation Choisissez la méthode d'installation selon votre système d'exploitation : ### macOS / Linux ```bash curl -fsSL https://antigravity.google/cli/install.sh | bash ``` ### Windows (PowerShell) ```powershell irm https://antigravity.google/cli/install.ps1 | iex ``` ### Windows (CMD) ```cmd curl -fsSL https://antigravity.google/cli/install.cmd -o install.cmd && install.cmd && del install.cmd ``` ### Vérification de l'installation ```bash agy --version ``` ## Configuration ### Activer le mode clé API Éditez `~/.gemini/antigravity-cli/settings.json` et ajoutez au JSON existant : ```json { "modelProvider": "gemini" } ``` ⚠️ **Attention** : définir uniquement `GEMINI_API_KEY` ne change pas le mode d'authentification. `modelProvider` doit impérativement valoir `"gemini"` en minuscules. ### Définir les variables d'environnement ```bash export GOOGLE_GEMINI_BASE_URL="https://aicentos.com" export GEMINI_API_KEY="your_api_key_here" ``` **Points importants :** * `GOOGLE_GEMINI_BASE_URL` reçoit l'adresse racine du service, sans chemin d'interface spécifique. Le point d'accès doit être compatible avec l'API Gemini. * `GEMINI_API_KEY` reçoit votre clé API. * Exécutez ces commandes dans le même shell que celui qui lance `agy`. La CLI ne lit ni `.env` ni `GOOGLE_API_KEY`. Pour un effet permanent, écrivez les deux `export` dans `~/.zshrc` ou `~/.bashrc`. ## Démarrage et vérification ```bash agy --model gemini-2.0-flash ``` Une fois `Gemini API key` affiché en haut, engagez une conversation. ### Dépannage des problèmes courants * **La connexion est toujours demandée** : vérifiez `"modelProvider": "gemini"`, puis quittez et relancez `agy`. * **Clé manquante au démarrage** : redéfinissez `GEMINI_API_KEY` dans le shell courant. * **Échec des requêtes** : vérifiez la clé API, l'adresse racine du service et les droits d'accès au modèle choisi. ## Remarques * La clé de configuration `modelProvider` et les variables d'environnement doivent être définies ensemble pour que le mode clé API fonctionne * Les variables d'environnement doivent être définies dans la session de shell qui lance la CLI, ou écrites dans le fichier de configuration du shell pour un effet permanent * Le point d'accès du service doit être conforme aux spécifications de l'API Gemini ## Liens utiles * Documentation officielle : [https://docs.aicentos.com/clients/antigravity-cli.html](https://docs.aicentos.com/clients/antigravity-cli.html) --- # Antigravity Source: https://docs.aicentos.com/fr/clients/antigravity Language: fr > Google Antigravity ne prend pas en charge de Base URL personnalisée : limites et alternatives disponibles Antigravity est l'IDE agentique de Google. Une précision s'impose d'entrée : **la version officielle de l'IDE de bureau Antigravity ne prend en charge ni point d'accès API personnalisé, ni BYOK (apportez votre propre clé)**. Le sélecteur de modèles propose une liste figée maintenue par Google ; pointer vers aicentos n'est pour l'instant pas possible. Cet article présente les fondements de cette limite, la méthode de vérification, ainsi que trois chemins alternatifs utilisables. ## Pourquoi une connexion directe est impossible La documentation des offres de compte de Google indique explicitement qu'Antigravity ne prend pas encore en charge les modèles ou points d'accès apportés par l'utilisateur. Plusieurs options de configuration qui circulent dans la communauté (par exemple `antigravity.ai.provider` ou `antigravity.openai-compatible.endpoint` dans `~/.antigravity/settings.json`) ne sont pas des clés officiellement prises en charge : en pratique, les requêtes ne sont pas routées vers le point d'accès personnalisé ou retombent silencieusement sur le modèle par défaut, et aucune entrée personnalisée n'apparaît dans le sélecteur de modèles. Autrement dit, le problème ne vient pas d'une « erreur de configuration » : la version actuelle n'ouvre tout simplement pas cette capacité. Les `Settings → Models` de l'IDE n'offrent d'ailleurs aucun champ Base URL à renseigner. ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | Clé API | clé créée dans la console | | Base URL | `https://aicentos.com/v1` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | Le tableau ci-dessus regroupe les paramètres génériques côté aicentos, utilisables par n'importe laquelle des alternatives ci-dessous. ## Alternatives ### Option 1 : passer à Antigravity CLI (recommandé, protocole Gemini uniquement) L'outil en ligne de commande homonyme `agy` accepte le remplacement du point d'accès : la connexion se fait via `GOOGLE_GEMINI_BASE_URL` + `GEMINI_API_KEY`, mais uniquement en protocole Gemini et avec les modèles de la gamme Gemini. Voir [Connecter Antigravity CLI](https://docs.aicentos.com/fr/clients/antigravity-cli) pour la procédure détaillée. Si votre besoin est « retrouver les interactions d'Antigravity dans le terminal », c'est la voie la plus simple. ### Option 2 : exposer un modèle local ou un service tiers comme outil MCP Le panneau Customizations d'Antigravity permet d'enregistrer des MCP Server. Vous pouvez encapsuler un service local en outil MCP et l'y attacher pour l'utiliser comme **outil appelable**. À noter : cela ne remplace pas le modèle de raisonnement de l'IDE, cela ajoute seulement un outil à l'agent. ### Option 3 : branche communautaire ou proxy local * La branche communautaire `open-antigravity` accepte n'importe quel point d'accès compatible OpenAI et des modèles personnalisés : c'est le chemin le plus propre en dehors de la version officielle. * D'autres utilisent un proxy d'interception local qui réécrit le trafic sortant de l'IDE. Cette voie n'a aucun soutien officiel, la configuration est fragile et elle casse à chaque mise à niveau ; déconseillée en production. ## Test Quel que soit le chemin choisi, confirmez d'abord la connectivité avec une invite simple avant l'usage réel. Pour les tâches d'agent, commencez par un petit dépôt. ## Remarques * **Ne prenez pas « une option de configuration qui semble exister » pour « une fonctionnalité disponible »**. Les clés `antigravity.*` de l'IDE relèvent pour la plupart de conjectures communautaires : les écrire ne provoque pas d'erreur, mais n'a aucun effet. * Si vous avez besoin du protocole compatible OpenAI ou souhaitez appeler les modèles de la gamme Claude / GPT, l'édition de bureau d'Antigravity ne peut pas y répondre pour l'instant ; privilégiez des clients acceptant une Base URL personnalisée comme [Cursor](https://docs.aicentos.com/fr/clients/cursor) ou [Windsurf](https://docs.aicentos.com/fr/clients/windsurf). * Antigravity CLI et l'IDE de bureau constituent deux configurations distinctes : le remplacement de point d'accès de la CLI n'affecte pas l'IDE. * Avant d'utiliser une branche ou un proxy tiers, évaluez vous-même sa sécurité et sa maintenance dans la durée. ## Liens utiles * [Connecter Antigravity CLI](https://docs.aicentos.com/fr/clients/antigravity-cli) --- # Augment Code Source: https://docs.aicentos.com/fr/clients/augment-code Language: fr > Augment Code n'ouvre pas de point d'accès personnalisé et ses modèles ne peuvent pas être remplacés par aicentos — justifications et alternatives Augment Code est une extension de codage pour VS Code / JetBrains / Vim, accompagnée d'un CLI `auggie`. Il **ne prend pas en charge de Base URL personnalisée et ne propose pas de BYOK** : les modèles viennent du catalogue officiel, le compte doit être connecté via `auggie auth login`, et les requêtes ne peuvent pas pointer vers aicentos. ## Pourquoi une connexion directe est impossible * Le fichier de configuration ne contient pas de champs comme `baseUrl` ou `apiKey`, et le panneau de réglages de l'extension n'offre aucun champ de saisie d'endpoint. * Le CLI ne reconnaît que deux variables d'environnement liées : `AUGMENT_SESSION_AUTH` (état de connexion) et `AUGMENT_DISABLE_AUTO_UPDATE` (désactiver la mise à jour automatique) ; aucune variable ne permet de remplacer l'endpoint. * `--model` n'accepte que les noms du catalogue officiel de modèles (Claude, GPT, Gemini, GLM, Kimi, etc.) ; un nom de modèle tiers est refusé. * L'index de la documentation officielle `docs.augmentcode.com/llms.txt` ne contient aucune entrée BYOK ni provider personnalisé. ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | API Key | clé créée dans la console | | Base URL | `https://aicentos.com/v1` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | Le tableau ci-dessus regroupe les paramètres génériques côté aicentos, utilisables par n'importe laquelle des alternatives ci-dessous. ## Alternatives ### Option 1 : passer à un agent de codage acceptant un endpoint personnalisé [Craft Agent](https://docs.aicentos.com/fr/clients/craft-agent), [Gajae Code](https://docs.aicentos.com/fr/clients/gajae-code) et [Oh My Pi](https://docs.aicentos.com/fr/clients/oh-my-pi) sont des agents de codage en terminal, dont la configuration accepte directement `baseUrl`. ### Option 2 : rester dans VS Code et changer d'extension [Cline](https://docs.aicentos.com/fr/clients/cline), [Roo Code](https://docs.aicentos.com/fr/clients/roo-code) et [Kilo](https://docs.aicentos.com/fr/clients/kilo) prennent tous en charge un provider compatible OpenAI : il suffit d'y saisir `https://aicentos.com/v1`. ### Option 3 : ne déplacer que les tâches par lots Si votre équipe a déjà souscrit à un abonnement Augment et ne veut pas renoncer à son expérience de complétion, vous pouvez conserver les modèles officiels pour l'édition quotidienne et déplacer les refactorisations massives et les tâches scriptées vers un CLI acceptant un endpoint personnalisé. ## Test Après être passé à l'un des clients alternatifs, confirmez d'abord la connectivité avec une invite simple, puis vérifiez dans la console que la consommation est bien imputée à la nouvelle clé. ## Remarques * Des tutoriels circulent en ligne avec des clés comme `augment.modelProvider: "openai-compatible"`, `augment.baseUrl` ou `augment.apiKeyEnv`. Ces clés n'existent pas dans la configuration officielle : les écrire ne provoque pas d'erreur mais n'a aucun effet, et `--model` continue de n'accepter que le catalogue officiel. * Ne prenez pas « une option de configuration qui ne renvoie pas d'erreur » pour « une configuration effective ». La vérification consiste à demander le nom du modèle courant, puis à le comparer au catalogue officiel. * L'index cloud et la complétion d'Augment n'ont pas d'équivalent : changer de client revient à changer toute la chaîne de travail, mieux vaut d'abord essayer sur un petit dépôt. ## Liens utiles * [Documentation d'Augment Code CLI](https://docs.augmentcode.com/cli/overview) --- # CC Switch Source: https://docs.aicentos.com/fr/clients/cc-switch Language: fr > Importer en un clic la configuration de la console aicentos vers CC Switch, pour gérer Claude Code / Codex / Gemini CLI CC Switch est un outil multiplateforme de gestion de configuration pour les CLI d'IA : il centralise la configuration des fournisseurs de modèles (Provider) d'outils comme Claude Code, Codex ou Gemini CLI, et permet de basculer en un clic entre plusieurs outils CLI ou plusieurs jeux de configuration, sans modifier sans cesse les variables d'environnement. La console aicentos intègre l'**import CC Switch en un clic** : inutile de recopier la Base URL et la clé à la main, quelques clics suffisent pour écrire la configuration dans CC Switch. ## Prérequis 1. Connectez-vous à la [console aicentos](https://aicentos.com/) 2. Vérifiez que le compte dispose d'un solde (¥1 de crédit d'essai offert à l'inscription ; rechargez via « **Portefeuille** » une fois épuisé) 3. Installez CC Switch (voir ci-dessous) ## Installation de CC Switch CC Switch est un projet open source hébergé sur GitHub : [farion1231/cc-switch](https://github.com/farion1231/cc-switch). Ouvrez la [page des Releases](https://github.com/farion1231/cc-switch/releases) et, dans les ressources de la dernière version, choisissez le paquet d'installation correspondant à votre système : * macOS : `.dmg` * Windows : `.msi` * Linux : `.AppImage` / `.deb` Une fois le téléchargement terminé, installez normalement selon votre système, puis **ouvrez CC Switch au moins une fois** : c'est ce qui permet au lien d'import de la console de détecter l'application sur votre machine. ## Import en un clic (recommandé) ### Étape 1 : lancer l'import depuis la console Ouvrez la rubrique « **Clés API** » dans la navigation de gauche de la console, cliquez sur « **⋯** » à droite de la ligne de la clé à utiliser, puis choisissez « **CC Switch** » dans le menu : Choix de CC Switch dans la liste des clés API ### Étape 2 : choisir l'application et le modèle Dans la fenêtre « **Remplir CC Switch** », choisissez l'application cible (Claude / Codex / Gemini) et confirmez le modèle à utiliser : Renseigner la configuration CC Switch | Champ | Description | | ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Application | Choisit la configuration de quel CLI écrire. **Claude** passe par le protocole Anthropic, **Codex** par le format compatible OpenAI, **Gemini** par le format natif Gemini | | Nom | Nom de la configuration telle qu'affichée dans CC Switch après l'import, personnalisable | | Modèle principal | Modèle utilisé par défaut par cette configuration, obligatoire | | Modèles Haiku / Sonnet | Modèles par palier pour l'application Claude, à préciser selon les besoins | Pour les noms de modèles, voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list), par exemple `claude-opus-4-8`, `claude-sonnet-5`, `claude-haiku-4-5`. Une fois choisi, cliquez sur « **Ouvrir CC Switch** ». ### Étape 3 : confirmer l'ouverture dans le navigateur Le navigateur demande s'il faut ouvrir CC Switch ; cliquez sur « **Ouvrir CC Switch.app** » : Confirmation d'ouverture de CC Switch par le navigateur > Si vous cochez « Toujours autoriser aicentos.com à ouvrir ce type de lien dans l'application associée », cette fenêtre de confirmation ne réapparaîtra plus lors des imports suivants. ### Étape 4 : confirmer l'import dans CC Switch CC Switch affiche « **Confirmer l'import de la configuration du fournisseur** » ; vérifiez les informations puis cliquez sur « **Importer** » : Confirmation de l'import dans CC Switch La fenêtre liste le point d'accès, la clé et les modèles par palier qui seront écrits ; après vérification, cliquez sur « **Importer** ». Une fois l'import terminé, `aicentos Claude` apparaît dans la liste des configurations de CC Switch ; un clic suffit pour basculer : Import terminé ## Configuration manuelle Si vous préférez éviter l'import en un clic, cliquez dans CC Switch sur « **Ajouter un nouveau fournisseur** » et renseignez à la main : Ajout d'un nouveau fournisseur dans CC Switch | Champ | Valeur à saisir | | ------------------ | ---------------------------------------------------------------------------------- | | Nom du fournisseur | `aicentos` (personnalisable, l'essentiel étant de le reconnaître) | | API Key | La clé créée sur la page « **Clés API** » de la console, de la forme `sk-xxxxxxxx` | | Adresse de requête | Claude / Gemini : `https://aicentos.com` ; Codex : `https://aicentos.com/v1` | > **Avec le protocole Anthropic, renseignez uniquement l'adresse racine** : n'ajoutez pas manuellement `/v1/messages`, le client l'ajoute lui-même. ## Prochaines étapes * [Surveillance de l'état des modèles](https://docs.aicentos.com/status) — consulter le taux de disponibilité en temps réel de chaque modèle * [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list) — voir la liste complète des modèles et leurs identifiants * [Facturation](https://docs.aicentos.com/fr/billing/pricing) — comprendre la recharge et la facturation à l'usage --- # Chatbot UI Source: https://docs.aicentos.com/fr/clients/chatbot-ui Language: fr > Utiliser aicentos dans Chatbot UI : connexion via des réglages personnalisés compatibles OpenAI Chatbot UI est un front-end web open source dans le style de ChatGPT, qui prend en charge une interface personnalisée compatible OpenAI. ## Configuration d'un déploiement auto-hébergé Pour une instance auto-hébergée, configurez l'interface personnalisée via des variables d'environnement : ```bash OPENAI_API_KEY=codex_your_api_key OPENAI_API_HOST=https://aicentos.com/v1 ``` Redémarrez le service après la configuration pour que la nouvelle interface prenne effet. Une fois les variables d'environnement définies, les champs correspondants de l'interface UI sont désactivés (pour éviter toute fuite de configuration sur une instance partagée). ## Configuration via l'interface UI Pour les instances qui ne restreignent pas les réglages de l'UI, renseignez dans le panneau de configuration : * **OpenAI API Key** : votre clé (`codex_...`, `sk-...`, etc.) * **OpenAI API Host / Base URL** : `https://aicentos.com/v1` ## Remarques * Chatbot UI nécessite Supabase pour l'authentification et le stockage des données * Renseignez l'API Host avec le chemin racine du service incluant `/v1` * Les modèles disponibles sont ceux renvoyés par `GET /v1/models` ## Liens utiles * GitHub : [https://github.com/mckaywrigley/chatbot-ui](https://github.com/mckaywrigley/chatbot-ui) --- # Chatbox Source: https://docs.aicentos.com/fr/clients/chatbox Language: fr > Utiliser aicentos dans Chatbox : connexion via des réglages personnalisés compatibles OpenAI Chatbox est un client IA de bureau qui prend en charge les interfaces compatibles OpenAI ; il se connecte à ce service via le mode « OpenAI API Compatible ». ## Ouvrir les réglages Cliquez sur l'icône **Settings (réglages)** de la barre latérale gauche, puis ouvrez l'onglet **Model (modèle)**. ## Choisir le fournisseur IA Dans le menu déroulant **Model Provider**, sélectionnez `OpenAI API Compatible` (API OpenAI compatible). ## Configuration à renseigner Renseignez les champs suivants : | Champ | Valeur à renseigner | | --------------------------- | -------------------------------------------------- | | API Key | votre clé (`codex_...`, `sk-...`, etc.) | | API Host (domaine de l'API) | `https://aicentos.com` | | Model (modèle) | `gpt-5-codex-mini` ou tout autre modèle disponible | **Remarque :** le champ **API Host** de Chatbox ne doit contenir que l'adresse racine du service, **sans** ajouter le suffixe `/v1`. Exemple : `https://aicentos.com` ## Test Après enregistrement, lancez une conversation et vérifiez que la réponse arrive normalement. ## Remarques * Renseignez l'API Host avec le chemin racine du service sans `/v1` ; Chatbox ajoute lui-même le chemin de l'interface * Les modèles disponibles sont ceux renvoyés par `GET /v1/models` ## Liens utiles * Documentation officielle : [https://docs.chatboxai.app/en/guides/providers](https://docs.chatboxai.app/en/guides/providers) --- # Cherry Studio Source: https://docs.aicentos.com/fr/clients/cherry-studio Language: fr > Utiliser aicentos dans Cherry Studio : ajouter un fournisseur compatible OpenAI pour accéder à tous les modèles Cherry Studio prend en charge les fournisseurs de modèles personnalisés compatibles OpenAI ; une fois aicentos ajouté, vous pouvez utiliser dans l'application tous les modèles intégrés par aicentos. ## Prérequis | Champ | Valeur | | ---------------------- | --------------------------------------------------------------------------- | | Nom du fournisseur | `aicentos` | | Adresse API (Base URL) | `https://aicentos.com/v1` | | API Key | à créer dans la console aicentos | | Nom du modèle | nom complet du modèle dans la « place de marché des modèles » de la console | La procédure d'obtention de l'API Key est décrite dans le [Démarrage rapide](https://docs.aicentos.com/fr/quickstart). ## Étapes de configuration * Ouvrez les réglages de Cherry Studio et rendez-vous dans **Services de modèles / Gestion des fournisseurs**. * Ajoutez un nouveau fournisseur **compatible OpenAI**. * Renseignez `aicentos` comme nom du fournisseur. * Saisissez l'API Key et l'adresse API `https://aicentos.com/v1`. * Enregistrez la configuration ; s'il existe un bouton « Détecter / Tester la connexion », cliquez dessus pour vérifier. ### Ajouter des modèles Si les modèles ne sont pas détectés automatiquement, vous pouvez ajouter les noms de modèles manuellement. > Le nom du modèle doit être copié intégralement : casse, traits d'union et suffixes de date ne doivent pas être modifiés ; référez-vous à la [place de marché des modèles](https://aicentos.com/pricing) / [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list). ## Test et dépannage Envoyez un message de test pour vérifier la connectivité, par exemple : ```bash Bonjour, présente-toi en une phrase. ``` Problèmes fréquents : * **Erreur d'authentification** : vérifiez que l'API Key ne contient pas d'espaces superflus. * **Délai dépassé** : vérifiez le réseau ou l'état du service. * **Modèle indisponible** : utilisez le nom complet du modèle tel qu'il figure dans la console. * **Échec de la conversation** : vérifiez que le fournisseur aicentos est bien sélectionné. --- # Claude Code Source: https://docs.aicentos.com/fr/clients/claude-code Language: fr > Installer Claude Code de zéro et le connecter à aicentos : environnement Node.js, installation Windows / Mac, variables d'environnement et configuration CC Switch, avec un tutoriel Termux pour mobile Claude Code est compatible avec le protocole Anthropic : il suffit de pointer la Base URL vers aicentos et de renseigner votre clé API pour profiter de tous les modèles Claude intégrés par aicentos. ## Étape 1 : installer Claude Code ### Installer l'environnement Node.js Rendez-vous sur le [site officiel de Node.js](https://nodejs.org/) pour télécharger la dernière version LTS, en choisissant le paquet d'installation correspondant à votre système d'exploitation. Téléchargement depuis le site officiel de Node.js Une fois l'installation terminée, ouvrez un terminal (git bash ou cmd sous Windows) et saisissez : ```bash node -v ``` Si un numéro de version s'affiche, l'installation a réussi. ### Installer Claude Code Avant l'installation, vérifiez que l'environnement Node.js ci-dessus est bien configuré. **Windows :** appuyez sur `Win + R`, tapez `cmd` puis Entrée pour ouvrir un terminal, et exécutez : ```bash npm install -g @anthropic-ai/claude-code ``` **Mac / Linux :** dans un terminal, exécutez : ```bash npm install -g @anthropic-ai/claude-code ``` ou utilisez le script curl recommandé officiellement : ```bash curl -fsSL https://claude.ai/install.sh | bash ``` Une fois l'installation terminée, testez qu'elle a réussi : ```bash claude --version ``` Si un numéro de version s'affiche, l'installation a réussi. claude --version installé avec succès ## Étape 2 : obtenir une clé API Rendez-vous dans la console du [site officiel d'aicentos](https://aicentos.com/) pour créer votre clé API. La procédure détaillée de création d'une clé est décrite dans le [Démarrage rapide](https://docs.aicentos.com/fr/quickstart). ## Étape 3 : configurer la connexion Deux approches sont possibles : **la gestion centralisée avec CC Switch** (recommandée) ou **la configuration manuelle**. ### Méthode 1 : avec CC Switch (recommandé) Si vous basculez fréquemment entre plusieurs providers ou plusieurs outils CLI, il est recommandé de centraliser la configuration avec CC Switch, sans avoir à modifier les variables d'environnement en permanence. Voir [Intégrer CC Switch →](https://docs.aicentos.com/fr/clients/cc-switch) ### Méthode 2 : configuration manuelle Si vous ne souhaitez pas installer d'outil supplémentaire, il suffit de configurer les variables d'environnement. Trois options au choix. #### Temporaire (session de terminal actuelle) Idéal pour un test rapide ; ne reste valable que dans la fenêtre de terminal en cours : ```bash export ANTHROPIC_BASE_URL="https://aicentos.com" export ANTHROPIC_AUTH_TOKEN="sk-votre-clé-API" export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 claude ``` Sur certaines versions, si `ANTHROPIC_AUTH_TOKEN` n'est pas reconnu, utilisez plutôt : ```bash export ANTHROPIC_API_KEY="sk-votre-clé-API" ``` #### Permanent (fichier de configuration, méthode manuelle recommandée) Éditez `~/.claude/settings.json` avec le contenu suivant : ```bash { "env": { "ANTHROPIC_BASE_URL": "https://aicentos.com", "ANTHROPIC_AUTH_TOKEN": "sk-votre-clé-API", "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1", "CLAUDE_CODE_ATTRIBUTION_HEADER": "0" } } ``` Sous **Windows**, vous pouvez aussi ouvrir les « variables d'environnement système », section « variables utilisateur », cliquer sur « Nouveau » et créer les deux variables suivantes : | Nom de la variable | Valeur | | ---------------------- | ------------------------ | | `ANTHROPIC_BASE_URL` | `https://aicentos.com` | | `ANTHROPIC_AUTH_TOKEN` | La clé créée à l'étape 2 | Redémarrez ensuite Claude Code pour que la modification prenne effet. #### Écriture dans la configuration du shell (effet global) Ajoutez les variables d'environnement à `~/.zshrc` ou `~/.bashrc` : ```bash nano ~/.zshrc ``` Ajoutez à la fin du fichier : ```bash # Clé API aicentos (celle créée à l'étape 2) export ANTHROPIC_AUTH_TOKEN="votre-clé" # Base URL aicentos export ANTHROPIC_BASE_URL="https://aicentos.com" ``` Enregistrez, quittez, puis exécutez `source ~/.zshrc` (ou rouvrez un terminal) pour appliquer. ## Étape 4 : lancer Claude Code Placez-vous dans votre répertoire de projet et lancez : ```bash cd /path/to/your/project claude ``` ## Choisir le modèle Au lancement, utilisez `--model` pour préciser le modèle : ```bash claude --model claude-opus-4-7 ``` Le nom du modèle doit correspondre à ceux listés dans la « place de marché des modèles » de la console aicentos ; voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list). ## Commandes courantes | Commande | Utilité | | ------------------------- | ------------------------------------------------------------------------------------------- | | `/add-dir` | Ajouter un répertoire de travail supplémentaire | | `/resume` | Revenir à une conversation passée | | `/clear` | Effacer l'historique de la conversation | | `/compact [instructions]` | Compacter la conversation, avec des instructions facultatives sur les points à conserver | | `/config` | Consulter / modifier la configuration | | `/cost` | Afficher les statistiques de consommation de tokens | | `/doctor` | Vérifier la bonne santé de l'installation de Claude Code | | `/help` | Obtenir de l'aide sur l'utilisation | | `/init` | Initialiser le projet avec un guide CLAUDE.md | | `/login` | Changer de compte Anthropic | | `/logout` | Se déconnecter du compte Anthropic | | `/mcp` | Gérer les connexions aux serveurs MCP et l'authentification OAuth | | `/memory` | Éditer le fichier mémoire CLAUDE.md | | `/model` | Sélectionner ou changer de modèle IA | | `/permissions` | Consulter ou mettre à jour les permissions | | `/pr_comments` | Consulter les commentaires d'une pull request | | `/review` | Demander une revue de code | | `/status` | Afficher l'état du compte et du système | | `/terminal-setup` | Installer le raccourci Shift+Entrée pour le retour à la ligne (iTerm2 et VSCode uniquement) | | `/vim` | Activer le mode vim, pour basculer entre insertion et commandes | ## Exécution sur mobile (Termux + Ubuntu) Adapté aux scénarios du type « pas d'ordinateur sous la main, un bug à corriger en déplacement, envie de vibe coder pendant le trajet ». Sans root, sans flasher le téléphone, le tout depuis Termux. Comptez 10 à 20 minutes au total, selon la vitesse du réseau. ### Ce que vous obtiendrez * Un environnement **Ubuntu** tournant dans le téléphone (sans impact sur le système, et peu gourmand en espace) * L'outil en ligne de commande **Claude Code** en version complète (à l'identique de la version ordinateur) * Une connexion à bas coût via **aicentos**, pour passer en un instant sur Opus / Sonnet / Haiku ### Prérequis Il ne faut que deux choses : * **Un téléphone Android** (Termux n'est pas disponible sur iOS, ce tutoriel ne s'y applique pas) * **Un compte [aicentos](https://aicentos.com) + une clé API** ([recharger le portefeuille →](https://aicentos.com/wallet), [créer une clé →](https://aicentos.com/keys)) **N'installez pas Termux depuis Google Play** : cette version est trop ancienne et n'est plus maintenue, les scripts suivants ne s'y installeraient pas. Téléchargez la dernière version depuis [F-Droid](https://f-droid.org/packages/com.termux/) ou les [Releases GitHub de Termux](https://github.com/termux/termux-app/releases). ### Étape 1 : installer le script tmoe-linux Ouvrez Termux, attendez l'invite de commandes (une ligne `~ $`), copiez-collez la ligne suivante **en entier** puis validez : ```bash . <(curl -L l.tmoe.me) ``` > Il s'agit d'un miroir dédié à la Chine continentale ; les utilisateurs hors Chine utiliseront `. <(curl -L git.io/linux.sh)`. À la fin de l'exécution, un **menu graphique** apparaît : Menu principal de tmoe Naviguez avec les touches de volume, validez avec Entrée (ou touchez directement l'écran). ### Étape 2 : installer le conteneur Ubuntu Dans le menu tmoe, choisissez successivement `安装 Linux 发行版` / `Install GNU/Linux container` pour accéder à la liste des distributions : Choix de la distribution Linux **Ubuntu est vivement recommandé** (la meilleure compatibilité, le plus de documentation apt, des réponses faciles à trouver en cas de problème). Prenez la dernière LTS (par exemple 22.04 / 24.04). Le téléchargement + l'extraction prennent quelques minutes selon le réseau ; patiencez. ### Étape 3 : entrer dans le conteneur et savoir « où vous en êtes » Une fois l'installation terminée, vous entrez probablement automatiquement dans le conteneur. **C'est l'étape où les débutants se perdent le plus facilement** ; voici comment faire la différence : **Vous êtes dans le conteneur Ubuntu** (l'invite ressemble à ceci) : Invite dans le conteneur **Vous êtes toujours dans Termux** (l'invite est plus sobre) : Invite hors du conteneur Dans le second cas, revenez dans Termux et saisissez : ```bash tmoe ``` Rouvrez le menu et choisissez `启动容器` / `Start container` pour y entrer. **Retenez cette règle** : installer Node, installer Claude Code, lancer la commande claude — **tout cela doit se faire dans le conteneur Ubuntu**. Le système de paquets `pkg` de Termux ne permet pas d'installer Claude Code. ### Étape 4 : installer Node.js et Claude Code Une fois que vous êtes bien dans le conteneur Ubuntu, exécutez successivement : ```bash # 1. Mettre à jour l'index des paquets apt apt update # 2. Installer Node.js + npm (la version fournie par Ubuntu suffit) apt install -y nodejs npm # 3. Installer Claude Code globalement npm install -g @anthropic-ai/claude-code ``` Si npm signale une erreur de permissions, ajoutez `sudo` devant. S'il n'y a pas de commande `sudo`, c'est que vous êtes root : exécutez directement. ### Étape 5 : connecter Claude Code à aicentos Par défaut, Claude Code se connecte au service officiel, ce qui pose deux problèmes pour la Chine : **pas de quota, et impossible de se connecter**. Modifions deux variables d'environnement pour le pointer vers aicentos : ```bash # 1. Installer l'éditeur de texte nano (souvent absent du conteneur) apt install -y nano # 2. Éditer la configuration de votre shell nano ~/.bashrc ``` Déplacez le curseur **tout à la fin** du fichier, ajoutez une nouvelle ligne et collez : ```bash export ANTHROPIC_BASE_URL=https://aicentos.com export ANTHROPIC_AUTH_TOKEN=votre-clé-API-générée-sur-aicentos.com ``` Remplacez `votre-clé-API-générée-sur-aicentos.com` par la clé API créée dans la [console aicentos](https://aicentos.com/keys) (commençant en général par `sk-`). Le résultat ressemble à ceci : Variables d'environnement ajoutées en fin de bashrc **Enregistrez et quittez** : * Appuyez sur `Ctrl + X` (touche Ctrl du clavier virtuel, présente par défaut dans Termux) * À la demande de sauvegarde, appuyez sur `Y` * Puis `Enter` pour confirmer le nom du fichier Pour appliquer immédiatement la configuration : ```bash source ~/.bashrc ``` ### Étape 6 : démarrage ```bash claude ``` **Au premier lancement**, on vous demande de choisir le mode de connexion : * Si vous vous étiez déjà connecté avec un compte officiel et souhaitez l'effacer, tapez `/logout` dans Claude Code ; après déconnexion, relancez `claude` et vos variables d'environnement seront utilisées * Sur une installation toute neuve, l'étape peut être passée et les variables d'environnement utilisées directement Dès que la boîte de dialogue de Claude Code apparaît, c'est gagné ; posez une question pour tester : ```bash Bonjour, écris-moi un script Python « hello world » ``` ### Aide-mémoire des commandes sur mobile Dans Claude Code : | Commande | Rôle | | ---------- | ------------------------------------------------------------------------------------------------------- | | `/model` | Changer de modèle (Opus / Sonnet / Haiku) | | `/logout` | Se déconnecter du compte courant (à utiliser une fois après un changement de variables d'environnement) | | `/clear` | Effacer le contexte de la session en cours | | `/help` | Voir toutes les commandes | | `Ctrl + C` | Interrompre la génération en cours | Hors du conteneur (dans Termux) : | Commande | Rôle | | ------------------- | ---------------------------------- | | `tmoe` | Ouvrir le menu principal de tmoe | | Lancer le conteneur | choisir « 启动容器 » dans le menu tmoe | ### Pièges courants sur mobile **1. `npm install -g` ne démarre pas / se bloque** Sans doute le réseau. Dans le conteneur, vous pouvez d'abord exécuter `npm config set registry https://registry.npmmirror.com` pour passer sur le miroir Taobao, puis relancer `npm install -g @anthropic-ai/claude-code`. **2. La commande `claude` est introuvable (not found)** Le chemin des commandes installées par `npm install -g` n'est pas dans le `PATH`. Ajoutez à la fin de `~/.bashrc` : ```bash export PATH="$PATH:$(npm config get prefix)/bin" ``` puis `source ~/.bashrc`. **3. Erreur 401 / solde insuffisant** Vérifiez le solde du [portefeuille aicentos](https://aicentos.com/wallet), et que `ANTHROPIC_AUTH_TOKEN` a été copié intégralement (attention aux espaces en début et fin). **4. Vous voulez un Sonnet et éviter que Opus ne brûle votre crédit** Après avoir lancé `claude`, tapez `/model` et choisissez sonnet. Ou fixez le modèle par défaut en ajoutant `export ANTHROPIC_MODEL=claude-sonnet-5` dans `.bashrc`. ### Pour aller plus loin sur mobile * Pour une saisie plus confortable : installez [Termux:Styling](https://f-droid.org/packages/com.termux.styling/) pour changer la police et les couleurs * Pour une interface graphique : le menu tmoe propose un bureau VNC, de quoi faire tourner un GNOME/XFCE complet sur le téléphone * Pour un fonctionnement de longue durée en arrière-plan : utilisez `tmux` ou `screen`, la session survit à la fermeture de Termux Le tutoriel s'arrête ici. Pour tout problème, n'hésitez pas à le signaler à la [communauté aicentos](https://aicentos.com). ## Remarques * La clé API s'obtient sur la page « Clés API » de la console. * `ANTHROPIC_AUTH_TOKEN` et `ANTHROPIC_API_KEY` : **choisissez l'un des deux, ne définissez jamais les deux à la fois**. * La Base URL ne doit contenir que l'adresse racine `https://aicentos.com` ; **n'ajoutez pas** manuellement `/v1/messages`, Claude Code le fait lui-même. * Après toute modification de la configuration, pensez à redémarrer le terminal / Claude Code. * Ne commitez jamais votre clé API dans un dépôt de code. --- # Cline Source: https://docs.aicentos.com/fr/clients/cline Language: fr > Configurer aicentos comme fournisseur compatible OpenAI dans l’extension Cline : Base URL et clé API Cline prend en charge nativement le provider OpenAI Compatible, qui se connecte directement à ce service. ## Installation Suivez la documentation officielle de Cline : * Avec VS Code, Cursor, Windsurf ou Antigravity, ouvrez le marché d'extensions, recherchez `Cline` et installez l'extension officielle * Avec JetBrains, ouvrez `Settings / Plugins / Marketplace`, recherchez `Cline`, installez puis redémarrez l'IDE * Si vous souhaitez uniquement la version terminal, consultez la documentation officielle de Cline CLI : `https://docs.cline.bot/cline-cli/installation` ## Ouvrir les réglages Dans le panneau Cline, cliquez sur le bouton de réglages pour accéder à la configuration du provider. ## Configuration à renseigner Réglez `API Provider` sur `OpenAI Compatible`, puis renseignez : * Base URL : `https://aicentos.com/v1` * API Key : votre clé (`codex_...`, `sk-...`, etc.) * Model ID : `gpt-5-codex-mini` Si le modèle n'apparaît pas automatiquement dans la liste déroulante, vous pouvez aussi saisir `gpt-5-codex-mini` manuellement. ## Test Après la saisie, cliquez sur `Verify` dans Cline ou lancez directement une nouvelle tâche. Si la connexion s'établit et que la session démarre, l'intégration fonctionne. ## Remarques * La documentation officielle de Cline utilise précisément le provider OpenAI Compatible * La Base URL doit contenir le chemin racine compatible OpenAI * Pour ce service, inutile de renseigner l'adresse racine du service, ni de compléter jusqu'au chemin complet `/chat/completions` --- # CodeBuddy Source: https://docs.aicentos.com/fr/clients/codebuddy Language: fr > Connecter le point d'accès compatible OpenAI d'aicentos dans CodeBuddy (IDE / CLI) via models.json CodeBuddy prend en charge les modèles personnalisés : via un `models.json` utilisateur ou de projet, les requêtes peuvent être pointées vers le point d'accès compatible OpenAI d'aicentos. L'IDE et la CLI CodeBuddy Code partagent la même configuration. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour CodeBuddy (nommez-la par exemple `codebuddy`). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) ## Configuration à renseigner | Champ | Valeur | | ------------------------------------ | ------------------------------------------------------------------- | | Base URL | `https://aicentos.com/v1` | | URL du point d'accès (champ `url`) | `https://aicentos.com/v1/chat/completions` | | API Key (`apiKey`) | La clé créée dans la console | | Identifiant du modèle (`id`) | nom du modèle dans la « place de marché des modèles » de la console | | `supportsToolCall` | `true` | | `maxInputTokens` / `maxOutputTokens` | selon le modèle choisi | Remarque : le champ `url` de `models.json` exige le **chemin d'interface complet**, qui doit se terminer par `/chat/completions`. ## Étapes de configuration * Ouvrez CodeBuddy une fois, pour qu'il génère son répertoire de configuration. * Créez ou éditez le fichier de configuration utilisateur : * macOS / Linux : `~/.codebuddy/models.json` * Windows : `C:\Users\\.codebuddy\models.json` * Pour ne viser qu'un seul projet, utilisez plutôt le fichier de projet `/.codebuddy/models.json`, prioritaire sur celui de l'utilisateur. * Écrivez le contenu suivant, en remplaçant `id` par le nom d'un modèle dont vous avez vérifié la disponibilité dans la console : ```json { "models": [ { "id": "gpt-5", "name": "GPT-5 (aicentos)", "vendor": "aicentos", "apiKey": "${AICENTOS_API_KEY}", "url": "https://aicentos.com/v1/chat/completions", "maxInputTokens": 128000, "maxOutputTokens": 16384, "supportsToolCall": true, "supportsImages": false, "supportsReasoning": false } ] } ``` * Définissez la variable d'environnement (`apiKey` et `url` acceptent tous deux les références `${VAR_NAME}`) : ```bash export AICENTOS_API_KEY="sk-votre-clé-aicentos" ``` * Quittez complètement CodeBuddy puis rouvrez (le redémarrage du panneau IDE suffit). * Sélectionnez le modèle que vous venez de configurer dans le sélecteur de modèles. Si vous préférez ne pas éditer de fichier, cliquez dans le panneau de conversation de l'IDE CodeBuddy sous le sélecteur de modèles → **Configurer un modèle personnalisé** → fournisseur **Custom**, puis renseignez la Base URL `https://aicentos.com/v1`, l'API Key et le nom du modèle. ## Test Après enregistrement, ouvrez une nouvelle conversation ou tâche de codage et commencez par un prompt simple et léger ; attendez une réponse normale avant un usage sérieux. ## Remarques * Seules les API au **format d'interface OpenAI** sont prises en charge pour l'instant. * `url` doit être le chemin complet `/v1/chat/completions` ; `https://aicentos.com/v1` seul n'aurait aucun effet. * La structure la plus externe doit être `{"models": [...]}` ; `models` est un champ de premier niveau obligatoire. * `availableModels` est une liste blanche : dès qu'elle est remplie, le menu déroulant des modèles ne montre que les modèles listés et les modèles intégrés disparaissent aussi. Omettez ce champ si vous ne souhaitez pas de restriction. * Enregistrez le fichier en **UTF-8 sans BOM** ; un JSON avec BOM empêche la lecture de la configuration des modèles locaux. * Les variables d'environnement sont résolues au démarrage ; si la variable n'existe pas, `${AICENTOS_API_KEY}` reste littéralement tel quel et provoque l'échec des appels. * Il est conseillé de donner au `models.json` les permissions `600` et de ne pas le commiter dans un dépôt. * La CLI peut aussi se configurer par variables d'environnement : `CODEBUDDY_API_KEY`, `CODEBUDDY_BASE_URL`, `CODEBUDDY_MODEL`. Avec `CODEBUDDY_BASE_URL`, ne mettez pas `/chat/completions` : la CLI l'ajoute elle-même. * Pour plus de détails, voir le site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) --- # Codebuff Source: https://docs.aicentos.com/fr/clients/codebuff Language: fr > Connecter aicentos à l'agent en ligne de commande Codebuff via son point de terminaison compatible OpenAI Codebuff est un agent de codage IA qui s'exécute dans le terminal et orchestre plusieurs sous-agents selon la tâche pour lire le code, élaborer un plan et modifier des fichiers. Par défaut, il se connecte au service hébergé officiel ; si votre version permet de remplacer le point de terminaison compatible OpenAI, vous pouvez diriger les requêtes vers aicentos via des variables d'environnement. ## Vérifier d'abord que votre version prend en charge les points de terminaison personnalisés Codebuff privilégie officiellement le mode hébergé : connexion avec les quotas officiels, ou utilisation de l'API officielle via `CODEBUFF_API_KEY`. La Base URL personnalisée n'est pas disponible dans toutes les versions ; vérifiez d'abord : * Exécutez `codebuff --help` et regardez s'il existe des options du type `--base-url` ou `--provider`. * Vérifiez si votre version lit `OPENAI_BASE_URL` (ou `CODEBUFF_BASE_URL` selon les versions) pour remplacer le point de terminaison. * Si ni l'un ni l'autre n'est pris en charge, votre version ne passe que par le service officiel et ne peut pas se connecter directement à aicentos. ## Prérequis Si vous avez confirmé que votre version prend en charge les points de terminaison personnalisés, créez d'abord, sur la page « API Key » de la console, une clé dédiée pour Codebuff (nommez-la par exemple `codebuff-cli`). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) Vérifiez aussi que Node.js est installé sur votre machine, ainsi que Codebuff installé globalement : ```bash npm install -g codebuff ``` ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | Base URL | `https://aicentos.com/v1` | | API Key | clé créée dans la console | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration * Écrivez le point de terminaison et la clé dans la configuration du shell (`~/.zshrc` ou `~/.bashrc`) : ```bash export OPENAI_API_KEY="sk-votre-clé-aicentos" export OPENAI_BASE_URL="https://aicentos.com/v1" ``` * Rechargez la configuration : `source ~/.zshrc`. * Placez-vous dans le répertoire du projet et lancez directement `codebuff`. * Si votre version prend en charge le paramètre `--model`, vous pouvez préciser le modèle explicitement au lancement ; sinon, changez de modèle avec la commande de sélection dans l'interface interactive. Certaines versions écrivent la configuration dans un fichier JSON du répertoire de configuration utilisateur (les fichiers d'identifiants ont par défaut les droits `600`, ne les commitez pas dans un dépôt). Si votre version utilise un fichier de configuration plutôt que des variables d'environnement, renseignez-y la même Base URL et la même clé, avec les noms de champs indiqués par `codebuff --help` ou la documentation officielle. ## Test Après le démarrage, faites d'abord un test léger avec une invite simple, par exemple lui demander de lire un fichier et d'en résumer le contenu ; une fois les résultats confirmés, utilisez-le normalement. ## Remarques * Les points de terminaison personnalisés relèvent d'un usage avancé ; les noms de champs peuvent varier selon les versions, référez-vous à la sortie de `codebuff --help` sur votre machine. * `OPENAI_BASE_URL` s'arrête à `https://aicentos.com/v1`, ne le complétez pas en chemin complet `/v1/chat/completions`. * Codebuff envoie des extraits de code et des sorties de terminal comme contexte ; vérifiez au préalable que cela est conforme aux exigences de conformité des données de votre équipe. * En cas d'erreur, vérifiez successivement : les variables d'environnement sont actives dans le terminal courant, le nom du modèle correspond à la console, le solde du compte est suffisant ([https://aicentos.com/wallet](https://aicentos.com/wallet)). * Pour plus de précisions, consultez le site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) --- # Codex CLI Source: https://docs.aicentos.com/fr/clients/codex-cli Language: fr > Utiliser aicentos dans Codex CLI : configurer manuellement model_providers dans config.toml Codex CLI est l'agent de codage en ligne de commande officiel d'OpenAI ; il définit les fournisseurs de modèles dans `~/.codex/config.toml`. Pointez un provider personnalisé vers aicentos et les modèles intégrés par aicentos deviennent utilisables dans le terminal. Si vous préférez gérer plusieurs configurations en mode graphique, passez plutôt par [CC Switch](https://docs.aicentos.com/fr/clients/cc-switch) pour basculer en un clic ; cet article ne traite que la configuration manuelle. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour Codex CLI (nommez-la par exemple `codex-cli`, pour suivre plus facilement sa consommation) : * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger en cas de solde insuffisant : [https://aicentos.com/wallet](https://aicentos.com/wallet) Vérifiez que Codex CLI est installé : ```bash codex --version ``` ## Configuration à renseigner | Champ | Valeur | | -------------------------------------- | ------------------------------------------------------------------- | | Provider ID | `aicentos` | | Nom du provider | `aicentos` | | Variable d'environnement de la clé API | `AICENTOS_API_KEY` | | Base URL | `https://aicentos.com/v1` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration ### 1. Définir la variable d'environnement de la clé API ```bash export AICENTOS_API_KEY="sk-votre-clé-API" ``` Pour un effet permanent, écrivez-la dans `~/.zshrc` ou `~/.bashrc`, faites un `source`, puis vérifiez avec `echo $AICENTOS_API_KEY`. ### 2. Éditer config.toml Ajoutez dans `~/.codex/config.toml` : ```toml model = "votre-nom-de-modèle" model_provider = "aicentos" [model_providers.aicentos] name = "aicentos" base_url = "https://aicentos.com/v1" env_key = "AICENTOS_API_KEY" wire_api = "responses" ``` Remplacez `votre-nom-de-modèle` par le nom d'un modèle listé dans la « place de marché des modèles » de la console, voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list). ### 3. Lancer Codex ```bash codex ``` Envoyez une requête simple pour vérifier que le provider fonctionne. ## Test ``` codex exec "Réponds en une phrase : combien font 1+1 ?" ``` Si du contenu est renvoyé normalement, la connexion fonctionne ; la réponse consomme un peu de crédit, que vous pouvez vérifier dans les journaux d'usage de la console. ## Remarques * **La Base URL s'arrête à `/v1`**, ne la complétez pas en chemin complet `/v1/chat/completions`. * Les champs `base_url`, `env_key`, etc. ne prennent effet que dans le `~/.codex/config.toml` utilisateur. Un `.codex/config.toml` écrit dans un projet est ignoré, et un avertissement peut apparaître au démarrage. * `wire_api` prend la valeur `responses`, qui correspond à l'[interface Responses](https://docs.aicentos.com/fr/api/chat/openai/responses) d'aicentos. La documentation officielle ne prend en charge que cette valeur à ce jour ; si votre version signale `unknown variant`, la CLI est trop ancienne, mettez-la à jour d'abord. * `openai`, `ollama` et `lmstudio` sont des identifiants de provider réservés : il est **impossible** de redéfinir le `base_url` du `openai` intégré pour pointer vers une passerelle tierce ; il faut créer un nouveau nom de provider (cet article utilise `aicentos`). * Ordre de dépannage : le nom du modèle correspond-il à la console → la Base URL s'arrête-t-elle à `/v1` → la variable d'environnement est-elle visible dans **le terminal qui lance codex** → le solde du compte est-il suffisant ? ## Liens utiles * [Intégrer Codex (méthode CC Switch)](https://docs.aicentos.com/fr/clients/codex) --- # Codex++ Source: https://docs.aicentos.com/fr/clients/codex-plus Language: fr > Connecter l'API GPT d'aicentos au Codex de votre ordinateur avec le lanceur Codex++ : mode pure API, configuration graphique, en quelques minutes [Codex++](https://github.com/BigPizzaV3/CodexPlusPlus) est un **lanceur enrichi externe et un outil de gestion** pour l'application Codex. Il ne modifie pas les fichiers d'installation d'origine de Codex : il lance Codex via un launcher externe et injecte des scripts d'enrichissement avec le protocole Chromium DevTools — vous pouvez donc l'utiliser sereinement, votre Codex d'origine reste intact. Ce tutoriel montre comment connecter **l'API GPT d'aicentos** au Codex de votre ordinateur : tout se fait en quelques clics dans l'interface graphique de Codex++, sans écrire de `config.toml` à la main. ## Prérequis * Un ordinateur (Windows / macOS pris en charge) * Un compte [aicentos](https://aicentos.com) et une clé créée sur la [page des clés API](https://aicentos.com/keys) ; nommez-la avec `codex` pour suivre plus facilement sa consommation À la création de la clé, faites attention à son **groupe** : il doit correspondre à celui des modèles que vous allez renseigner ci-dessous, sinon une erreur de permission apparaîtra. ## Étape 1 : télécharger et installer Codex++ Ouvrez la page officielle des Releases GitHub : [github.com/BigPizzaV3/CodexPlusPlus/releases](https://github.com/BigPizzaV3/CodexPlusPlus/releases) Page de téléchargement des Releases de Codex++ Dans la dernière version, choisissez le paquet d'installation **correspondant à votre système**, téléchargez-le, installez-le et ouvrez-le. Vous arrivez alors sur l'outil de gestion Codex++ : Interface de l'outil de gestion Codex++ ## Étape 2 : ajouter un fournisseur Cliquez sur « **Ajouter un fournisseur** » pour créer une nouvelle configuration de connexion : Ajouter un fournisseur Renseignez selon le tableau : | Champ | Valeur à saisir | | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------ | | Nom | Le nom du relais, l'essentiel étant de le reconnaître (par exemple `aicentos`) | | Mode de connexion | **Pure API** | | Modèles configurés | Renseignez les modèles pris en charge par aicentos, **en copiant le nom du modèle en entier**, séparés par des virgules, par exemple `gpt-5.5,gpt-5.4` | ## Étape 3 : renseigner la cible Codex Dans « Cible Codex », **activez ✅**, puis renseignez les deux champs suivants : | Champ | Valeur | | -------- | ------------------------------------------------------------------------------- | | Base URL | `https://aicentos.com` | | Key | La clé générée dans la gestion des tokens aicentos, correspondant au bon groupe | Renseigner la Base URL et la Key Pour le **protocole amont**, choisissez bien **chat completions** ; tout autre protocole ferait échouer les requêtes. Protocole amont : chat completions Une fois rempli, cliquez sur « **Enregistrer** » en haut. ## Étape 4 : redémarrer Codex Après l'enregistrement, cliquez sur « **Redémarrer** » en haut à droite pour appliquer la configuration : Redémarrer Codex ## Étape 5 : se connecter avec la clé Après le redémarrage, choisissez « **Utiliser une autre méthode de connexion** » : Utiliser une autre méthode de connexion Collez la clé générée dans la [gestion des tokens aicentos](https://aicentos.com/keys), puis cliquez sur « **Continuer** » : Coller la clé et continuer La connexion est alors terminée, vous pouvez commencer à utiliser Codex. ## Résolution des problèmes En cas d'échec d'une requête, comparez la sortie de Codex aux journaux d'usage de la [console aicentos](https://aicentos.com). Causes fréquentes : * **Nom de modèle mal saisi** : référez-vous aux [modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list) d'aicentos et copiez le nom du modèle en entier. * **Mauvais protocole amont** : il doit s'agir de **chat completions**. * **Base URL incorrecte** : renseignez `https://aicentos.com`, sans espace ni chemin superflu en début ou fin. * **Erreur 401 / pas de permission** : vérifiez que la clé a été copiée en entier et que son groupe couvre bien le modèle souhaité ; le solde se consulte sur le [Portefeuille](https://aicentos.com/wallet). --- # Codex Source: https://docs.aicentos.com/fr/clients/codex Language: fr > Utiliser aicentos dans Codex : import en un clic via CC Switch, ou configuration manuelle de config.toml Codex est compatible avec le protocole OpenAI : pointez le fournisseur de modèles vers aicentos pour utiliser tous les modèles intégrés par aicentos. Deux approches sont proposées ci-dessous : **la gestion en un clic avec CC Switch** (recommandée), ou **l'édition manuelle de config.toml**. ## Méthode 1 : avec CC Switch (recommandé) CC Switch sait aussi gérer la configuration de Provider de Codex, avec bascule en un clic entre plusieurs jeux de configuration. Voir [Intégrer CC Switch →](https://docs.aicentos.com/fr/clients/cc-switch) ## Méthode 2 : configuration manuelle ### Prérequis | Élément | Valeur | | ------------------------------------- | ------------------------- | | Provider ID | `aicentos` | | Nom du provider | `aicentos` | | Base URL | `https://aicentos.com/v1` | | Variable d'environnement de l'API Key | `AICENTOS_API_KEY` | Créez d'abord, sur la page « API Key » de la console, une clé dédiée, avec `codex` dans son nom pour suivre plus facilement sa consommation. ### Définir l'API Key Définissez la variable d'environnement dans le terminal : ```bash export AICENTOS_API_KEY="sk-votre-clé-API" ``` Pour la rendre permanente, ajoutez-la à `~/.zshrc` ou `~/.bashrc`, puis rechargez : ```bash source ~/.zshrc ``` Vérifiez que la variable est bien prise en compte : ```bash echo $AICENTOS_API_KEY ``` ### Configurer le provider Codex Éditez `~/.codex/config.toml` en y ajoutant : ```bash model = "votre-nom-de-modèle" model_provider = "aicentos" [model_providers.aicentos] name = "aicentos" base_url = "https://aicentos.com/v1" env_key = "AICENTOS_API_KEY" wire_api = "responses" ``` Remplacez `votre-nom-de-modèle` par un nom de modèle listé dans la « place de marché des modèles » de la console ; voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list). ### Lancer Codex ```bash codex ``` Envoyez une requête simple pour vérifier que le provider fonctionne correctement. ## Résolution des problèmes En cas d'échec des requêtes, comparez la sortie du terminal Codex avec le journal de consommation de la console. Causes fréquentes : * Nom de modèle mal orthographié (référez-vous à la place de marché des modèles). * Format de Base URL incorrect (arrêtez-la à `/v1`, sans chemin supplémentaire). * Variable d'environnement non lue par le terminal courant (rouvrez un terminal ou `source` le fichier de configuration). --- # Command Code Source: https://docs.aicentos.com/fr/clients/command-code Language: fr > Utiliser aicentos dans Command Code : ajout d'un fournisseur BYOK via providers.json Command Code est un agent de codage pour le terminal qui utilise par défaut ses fournisseurs intégrés, tout en prenant en charge le BYOK : déclarez un fournisseur personnalisé dans `~/.commandcode/providers.json` et pointez le baseURL vers aicentos. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour Command Code (nommez-la par exemple `command-code`, pour suivre plus facilement sa consommation) : * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger en cas de solde insuffisant : [https://aicentos.com/wallet](https://aicentos.com/wallet) ## Configuration à renseigner | Champ | Valeur | | ------------------------ | ------------------------------------------------------------------- | | Fichier de configuration | `~/.commandcode/providers.json` | | baseURL | `https://aicentos.com/v1` | | apiKey | `$AICENTOS_API_KEY` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration ### 1. Définir les variables d'environnement ```bash export AICENTOS_API_KEY="sk-votre-clé-API" ``` Écrivez-la dans `~/.zshrc` ou `~/.bashrc` pour un effet permanent. ### 2. Éditer providers.json Éditez `~/.commandcode/providers.json` et ajoutez une entrée sous l'objet `provider` : ```json { "provider": { "aicentos": { "name": "aicentos", "api": "openai-completions", "baseURL": "https://aicentos.com/v1", "apiKey": "$AICENTOS_API_KEY", "models": { "gpt-4o": {} } } } } ``` Détail des champs : | Champ | Description | | --------- | ----------------------------------------------------------------------------------------------- | | `name` | Nom d'affichage, visible dans `/connect` et `/model` | | `api` | `openai-completions` (par défaut) ou `anthropic-messages` | | `baseURL` | Obligatoire, adresse racine de l'API, avec `/v1` | | `apiKey` | Accepte `$VAR`, `{env:VAR}`, `!command`, ou `false` pour un point d'accès sans authentification | | `models` | Obligatoire, `{}` suffit ; les identifiants de modèles doivent correspondre au point d'accès | Remplacez les identifiants de modèles dans `models` par les noms de la « place de marché des modèles » de la console, voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list). ### 3. Choisir le fournisseur Une fois dans Command Code : * exécutez `/connect`, sélectionnez `aicentos` et confirmez la clé ; * exécutez `/model` et choisissez le modèle à utiliser. Remarque : **après modification de `providers.json`, il faut rouvrir `/model`** pour que la nouvelle configuration soit chargée. ## Test Une fois le modèle choisi, envoyez un prompt simple : ``` Réponds en une phrase : combien font 1+1 ? ``` Une réponse normale signifie que la connexion fonctionne. Vous pouvez aussi, dans `/connect`, appuyer sur `u` sur le fournisseur pour qu'il interroge le `/models` du point d'accès et rafraîchisse la liste des modèles. ## Remarques * Command Code passe par défaut par Chat Completions compatible OpenAI ; `api` à `openai-completions` suffit donc. * Pour utiliser les modèles Claude, créez une autre entrée de fournisseur avec `api: "anthropic-messages"` — les deux protocoles ne construisent pas les chemins de la même façon (le SDK OpenAI ajoute `/chat/completions`, le SDK Anthropic `/v1/messages`), et un même baseURL ne peut pas servir les deux. * `baseURL` doit contenir `/v1` ; Command Code ajoute lui-même les chemins suivants. * Une clé collée en clair directement dans `apiKey` est refusée ; utilisez la forme `$VAR`. * Ordre de dépannage : le modèle est-il visible dans `/model` → la variable d'environnement est-elle visible dans le terminal de lancement → le baseURL s'arrête-t-il bien à `/v1` → le solde est-il suffisant ? ## Liens utiles * Documentation BYOK officielle : [https://commandcode.ai/docs/byok](https://commandcode.ai/docs/byok) --- # GitHub Copilot Source: https://docs.aicentos.com/fr/clients/copilot Language: fr > Connecter aicentos à GitHub Copilot Chat via BYOK (clé personnelle) sur le point de terminaison compatible OpenAI Dans VS Code, GitHub Copilot offre la capacité BYOK (Bring Your Own Key) qui permet de diriger les requêtes de conversation vers un point de terminaison personnalisé compatible OpenAI. Réglez le point de terminaison sur aicentos et renseignez la clé créée dans la console pour utiliser, dans Copilot Chat / Agent, les modèles intégrés par aicentos. ## Prérequis Créez d'abord, sur la page « API Key » de la console, une clé dédiée pour Copilot (nommez-la par exemple `copilot-vscode` ou `copilot-work`, pour suivre plus facilement sa consommation). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) Vérifiez aussi que VS Code et l'extension GitHub Copilot Chat de votre machine sont à jour, dans une version prenant en charge les points de terminaison personnalisés ; les versions plus anciennes n'offrent le BYOK que pour les fournisseurs intégrés, sans entrée générique de « point de terminaison personnalisé ». ## Configuration à renseigner | Champ | Valeur | | ------------ | -------------------------------------------------------------------------- | | Provider | Custom Endpoint (OpenAI Compatible dans les versions antérieures) | | Base URL | `https://aicentos.com/v1` | | Type d'API | Chat Completions (correspond à `https://aicentos.com/v1/chat/completions`) | | API Key | clé créée dans la console | | Model ID | nom du modèle dans la « place de marché des modèles » de la console | | Tool Calling | `true` (obligatoire pour une utilisation en mode Agent) | ## Étapes de configuration ### Méthode 1 : interface graphique * Ouvrez la vue Chat de VS Code. * Cliquez sur le sélecteur de modèles au-dessus de la zone de saisie et choisissez **Manage Language Models** (**Manage Models...** dans les versions antérieures). * Cliquez sur **Add Models** puis sélectionnez **Custom Endpoint** dans la liste des fournisseurs (**OpenAI Compatible** dans les versions antérieures). * Saisissez le nom du groupe et l'API Key. * Choisissez **Chat Completions** comme type d'API. * Complétez les informations du modèle comme demandé : `id` reçoit le nom du modèle de la console, `url` reçoit `https://aicentos.com/v1/chat/completions`. * Après enregistrement, revenez au Chat et sélectionnez le modèle ajouté dans le menu déroulant. ### Méthode 2 : settings.json Exécutez **Preferences: Open User Settings (JSON)** dans la palette de commandes, puis ajoutez : ```json { "github.copilot.chat.customOAIModels": { "aicentos-gpt": { "name": "aicentos GPT", "url": "https://aicentos.com/v1/chat/completions", "toolCalling": true, "vision": false, "maxInputTokens": 128000, "maxOutputTokens": 16384 } } } ``` La clé au niveau le plus externe de l'objet (par ex. `aicentos-gpt`) est l'ID de modèle que vous verrez dans le sélecteur de modèles ; il doit être unique. Documentation officielle de référence : [https://code.visualstudio.com/docs/copilot/customization/language-models](https://code.visualstudio.com/docs/copilot/customization/language-models) ## Test Après enregistrement des réglages, créez une nouvelle conversation dans le Chat et faites d'abord un test léger avec une invite simple ; si la réponse revient normalement, la connexion est établie, et vous pouvez utiliser les modes Agent / Edit. ## Remarques * BYOK ne s'applique qu'à **Chat / Agent / Edit** et ne couvre pas la complétion de code en ligne (complétion Tab) ; la recherche sémantique, les embeddings et autres capacités continuent de passer par le service intégré de Copilot. * Pour une utilisation en mode **Agent**, le modèle doit prendre en charge le **tool calling** et `toolCalling` doit être réglé sur `true` ; sinon le modèle n'apparaît pas dans le sélecteur de modèles. * Le champ `url` doit contenir l'URL complète `https://aicentos.com/v1/chat/completions`, pas seulement jusqu'à `/v1`. * `github.copilot.chat.customOAIModels` est l'ancienne écriture ; les versions récentes utilisent `chatLanguageModels.json` avec `customendpoint` ; référez-vous à l'entrée réelle de votre version de VS Code. * Avec GitHub Copilot Business / Enterprise, l'administrateur peut désactiver le BYOK par stratégie. * Si le modèle ajouté n'apparaît pas immédiatement, redémarrez VS Code. * En cas d'erreur, vérifiez successivement : la clé ne contient pas d'espaces superflus, le nom du modèle correspond à la console, le solde du compte est suffisant, le type d'API est bien choisi. En cas de solde insuffisant, rechargez sur [https://aicentos.com/wallet](https://aicentos.com/wallet). --- # Craft Agent Source: https://docs.aicentos.com/fr/clients/craft-agent Language: fr > Connecter aicentos à Craft Agent — connexion personnalisée compatible OpenAI, valable pour le client de bureau comme pour craft-cli La connexion LLM de Craft Agent prend en charge le type `Custom`, décrit officiellement comme « n'importe quelle URL, n'importe quel endpoint compatible OpenAI ou compatible Anthropic ». Pointez la Base URL vers aicentos : le client de bureau comme `craft-cli` peuvent l'utiliser. ## Prérequis Créez d'abord dans la console une clé dédiée pour Craft Agent (nommez-la par exemple `craft-agent`), pour suivre facilement la consommation par clé. * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) Installez le client de bureau : ```bash curl -fsSL https://thecraftagents.com/install-app.sh | bash ``` Le mode headless server et l'usage en ligne de commande pure sont également pris en charge. ## Configuration à renseigner | Champ | Valeur | | ----------------- | --------------------------------------------------------------------------------------------- | | Type de connexion | Custom (personnalisé) | | Protocole | `openai-completions`, ou `anthropic-messages` | | Base URL | `https://aicentos.com/v1` (compatible OpenAI) / `https://aicentos.com` (compatible Anthropic) | | API Key | clé créée dans la console | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration Client de bureau : ouvrez les connexions LLM dans les réglages, ajoutez-en une, choisissez le type Custom et renseignez les champs du tableau ci-dessus. Équivalent en ligne de commande : ```bash export AICENTOS_API_KEY="sk-votre-clé-API" craft-cli run --provider openai \ --base-url https://aicentos.com/v1 \ --api-key "$AICENTOS_API_KEY" \ --model votre-nom-de-modèle \ "bonjour" ``` Vous pouvez aussi modifier directement le fichier de configuration `~/.craft-agent/config.json` : ```json { "llmConnections": [ { "providerType": "pi_compat", "baseUrl": "https://aicentos.com/v1", "customEndpoint": { "api": "openai-completions" }, "models": [{ "id": "votre-nom-de-modèle" }], "defaultModel": "votre-nom-de-modèle" } ] } ``` La clé n'est pas écrite en clair dans la configuration : elle est stockée dans `credentials.enc`, dans le même répertoire. Renseignez-la une fois via l'interface et ne modifiez pas ce fichier à la main. ## Test ```bash craft-cli run --provider openai \ --base-url https://aicentos.com/v1 \ --api-key "$AICENTOS_API_KEY" \ --model votre-nom-de-modèle \ "Présente-toi en une phrase" ``` Si la réponse revient normalement, la connexion fonctionne. Retournez ensuite dans la console consulter la consommation pour confirmer que la requête est bien imputée à cette clé. ## Remarques * Gardez `providerType` sur `pi_compat`, c'est l'identifiant de son endpoint personnalisé ; le remplacer par le nom d'un provider intégré ferait passer par les modèles officiels. * `models` doit être renseigné à la main : la liste des modèles n'est pas récupérée automatiquement. Le nom doit correspondre exactement à celui de la « place de marché des modèles » de la console (voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list)). * Avec l'endpoint compatible Anthropic, la Base URL est `https://aicentos.com`, sans `/v1`, et `--provider` devient `anthropic`. * L'emplacement des menus du client de bureau varie selon les versions ; si vous ne les trouvez pas, fiez-vous à la syntaxe de `config.json`. ## Liens utiles * [Documentation Craft Agents](https://thecraftagents.com/docs) * [Dépôt craft-agents](https://github.com/craft-ai-agents/craft-agents-oss) --- # Crush Source: https://docs.aicentos.com/fr/clients/crush Language: fr > Utiliser aicentos dans Crush —— ajout d'un provider personnalisé via crush.json Crush est un agent de codage pour terminal édité par Charmbracelet, écrit en Go, qui permet de déclarer dans `crush.json` n'importe quel provider personnalisé compatible OpenAI. Pointez le base\_url vers aicentos et les modèles intégrés par aicentos deviennent utilisables dans la TUI. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour Crush (nommez-la par exemple `crush`, pour suivre plus facilement sa consommation) : * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger en cas de solde insuffisant : [https://aicentos.com/wallet](https://aicentos.com/wallet) Vérifiez que Crush est installé : ```bash crush --version ``` ## Configuration à renseigner | Champ | Valeur | | ------------------------ | ------------------------------------------------------------------- | | Fichier de configuration | `~/.config/crush/crush.json` | | type | `openai-compat` | | base\_url | `https://aicentos.com/v1` | | api\_key | `$AICENTOS_API_KEY` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration ### 1. Définir la variable d'environnement de la clé API ```bash export AICENTOS_API_KEY="sk-votre-clé-API" ``` Pour un effet permanent, écrivez-la dans `~/.zshrc` ou `~/.bashrc`, puis faites un `source`. ### 2. Éditer crush.json Le fichier de configuration global se trouve dans `~/.config/crush/crush.json` (sous Windows : `%USERPROFILE%\AppData\Local\crush\crush.json`) ; un `.crush.json` ou `crush.json` à la racine du projet remplace la configuration globale. Écrivez : ```json { "$schema": "https://charm.land/crush.json", "providers": { "aicentos": { "type": "openai-compat", "base_url": "https://aicentos.com/v1", "api_key": "$AICENTOS_API_KEY", "models": [ { "id": "gpt-4o", "name": "GPT-4o", "context_window": 128000, "default_max_tokens": 8192, "can_reason": true } ] } } } ``` `models[].id` doit correspondre exactement à l'identifiant de modèle côté point d'accès ; référez-vous à la « place de marché des modèles » de la console, voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list). ### 3. Choisir le modèle Après avoir lancé `crush`, appuyez sur `Ctrl+L` dans la TUI (ou tapez `/model`) et vérifiez que `aicentos` et ses modèles apparaissent. ## Test Faites une vérification rapide en mode non interactif : ```bash crush run "Réponds en une phrase : combien font 1+1 ?" ``` Ajoutez `--debug` pour voir les journaux des requêtes. En cas de 404, vérifiez que `base_url` contient bien `/v1`. ## Remarques * **Ne mettez pas `openai` dans `type`**. `openai` est réservé aux proxys qui passent réellement par OpenAI (ou Azure OpenAI) ; pour pointer vers un point d'accès compatible tiers, il faut `openai-compat`, sinon des erreurs de reconnaissance de modèle ou d'API peuvent survenir. * `base_url` s'arrête à `/v1`, sans barre oblique finale. * `api_key` accepte l'expansion `$VAR` et `$(command)` ; gardez de préférence la clé dans une variable d'environnement ou un fichier de secrets, ne l'écrivez jamais en clair en dur. * Pour un point d'accès au protocole Anthropic (`type` à `anthropic`), `base_url` doit s'arrêter à `/api` : Crush ajoute lui-même `/v1/messages`, et il faut en plus déclarer `anthropic-version` dans `extra_headers`. * Problème connu : avec un provider personnalisé, le comptage de tokens et les coûts peuvent afficher 0 dans la TUI, sans incidence sur les requêtes ni la facturation. * Pour activer la sortie de raisonnement, utilisez `"can_reason": true` avec `"reasoning_effort"` sur les modèles de style OpenAI, et `"think": true` sur les modèles de style Anthropic. ## Liens utiles * Documentation des providers personnalisés : [https://github.com/charmbracelet/crush](https://github.com/charmbracelet/crush) --- # Cursor Source: https://docs.aicentos.com/fr/clients/cursor Language: fr > Utiliser aicentos dans Cursor : connexion via des réglages personnalisés compatibles OpenAI Cursor prend en charge une API personnalisée compatible OpenAI : pointez la Base URL vers aicentos et renseignez l'API Key pour utiliser, dans Chat / Composer, les modèles intégrés par aicentos. ## Prérequis Créez d'abord, sur la page « API Key » de la console, une clé dédiée pour Cursor (nommez-la par exemple `cursor-desktop` ou `cursor-work`, pour suivre plus facilement sa consommation). ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | API Key | clé créée dans la console | | Base URL | `https://aicentos.com/v1` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration * Ouvrez les réglages de Cursor (Settings). * Rendez-vous dans la zone **Models** ou **API Keys**. * Repérez l'option **OpenAI API Key** / réglages personnalisés compatibles OpenAI / remplacement de la **Base URL**. * Saisissez l'API Key créée dans la console aicentos. * Réglez la Base URL sur : `https://aicentos.com/v1` * Pour ajouter un modèle manuellement, renseignez le nom du modèle figurant dans la console (voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list)). * Enregistrez puis cliquez sur **Verify**, ou testez directement avec une nouvelle conversation. ## Test Après enregistrement, faites d'abord un test léger avec une invite simple ; une fois la connexion confirmée, utilisez Composer / Chat normalement. ## Remarques * La clé API personnalisée ne s'applique en général qu'aux modèles de conversation standards. * La **complétion Tab** et certaines capacités d'**Agent** peuvent continuer à passer par le service intégré de Cursor. * En cas d'échec de Verify, vérifiez : la Base URL est correcte (arrêtée à `/v1`), la clé ne contient pas d'espaces superflus, le modèle est disponible, le solde du compte est suffisant et le provider OpenAI personnalisé est bien sélectionné. --- # Devin CLI Source: https://docs.aicentos.com/fr/clients/devin-cli Language: fr > Utiliser aicentos dans Devin CLI : connexion via une configuration compatible OpenAI Devin CLI est le client en ligne de commande de Devin ; il permet de préciser une adresse API compatible OpenAI via des variables d'environnement ou un fichier de configuration. Pointez la Base URL vers aicentos et renseignez l'API Key pour utiliser, dans le terminal, les modèles intégrés par aicentos. ## Prérequis Créez d'abord, sur la page « API Key » de la console, une clé dédiée pour Devin CLI (nommez-la par exemple `devin-cli`, pour suivre plus facilement sa consommation). ## Installation Node.js 18+ et npm sont nécessaires au préalable : ```bash node -v npm -v ``` Installez globalement avec npm : ```bash npm install -g devin-cli ``` Une fois l'installation terminée, vérifiez : ```bash devin --version ``` ## Étapes de configuration Deux méthodes sont possibles : variables d'environnement ou fichier de configuration ; les variables d'environnement ont la priorité. ### Méthode 1 : variables d'environnement (recommandé) ```bash export DEVIN_BASE_URL="https://aicentos.com/v1" export DEVIN_API_KEY="your_api_key_here" ``` Pour un effet permanent, écrivez-les dans `~/.zshrc` ou `~/.bashrc`, puis exécutez `source ~/.zshrc`. ### Méthode 2 : fichier de configuration Éditez `~/.devin/config.json` : ```json { "apiKey": "your_api_key_here", "baseURL": "https://aicentos.com/v1", "model": "gpt-4o" } ``` ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | API Key | clé créée dans la console | | Base URL | `https://aicentos.com/v1` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Test Une fois la configuration terminée, lancez directement : ```bash devin ``` Dans la session interactive, envoyez une invite simple ; si vous recevez une réponse normalement, l'intégration fonctionne. En cas d'erreur d'authentification, vérifiez que `DEVIN_API_KEY` est correcte, que `DEVIN_BASE_URL` porte bien le suffixe `/v1` et que le solde du compte est suffisant. ## Remarques * La Base URL s'arrête à `/v1`, ne la complétez pas en chemin complet `/v1/chat/completions` * En cas de coexistence des variables d'environnement et du fichier de configuration, les variables d'environnement prévalent * Il est conseillé de vérifier d'abord les modèles visibles avec `GET /v1/models` avant de renseigner le Model ID --- # Devin Desktop Source: https://docs.aicentos.com/fr/clients/devin-desktop Language: fr > Utiliser aicentos dans Devin Desktop : connexion via des réglages personnalisés compatibles OpenAI Devin Desktop est le client de bureau de Devin ; il prend en charge une adresse API personnalisée compatible OpenAI. Pointez la Base URL vers aicentos et renseignez l'API Key pour utiliser, dans le client, les modèles intégrés par aicentos. ## Prérequis Créez d'abord, sur la page « API Key » de la console, une clé dédiée pour Devin Desktop (nommez-la par exemple `devin-desktop`, pour suivre plus facilement sa consommation). ## Installation Rendez-vous sur le site officiel de Devin pour télécharger le paquet d'installation correspondant à votre plateforme : * macOS : téléchargez le `.dmg` et glissez-le dans « Applications » * Windows : téléchargez l'installateur `.exe` et exécutez-le * Linux : téléchargez le `.AppImage` ou le `.deb` et installez selon les usages de votre distribution Une fois l'installation terminée, lancez l'application, connectez-vous et accédez aux réglages. ## Étapes de configuration * Ouvrez **Settings** (réglages). * Rendez-vous dans la zone **Models** ou **AI Provider**. * Repérez l'option **OpenAI Compatible** / **Custom Provider** / remplacement de la **Base URL**. * Saisissez l'API Key créée dans la console aicentos. * Réglez la Base URL sur : `https://aicentos.com/v1` * Pour ajouter un modèle manuellement, renseignez le nom du modèle de la « place de marché des modèles » de la console. * Enregistrez les réglages. ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | API Key | clé créée dans la console | | Base URL | `https://aicentos.com/v1` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Test Après enregistrement, créez une nouvelle conversation ou une tâche de codage, testez avec une invite simple ; si les résultats reviennent normalement, l'intégration a réussi. ## Remarques * Le nom des entrées de réglages peut varier selon les versions ; l'essentiel est de trouver l'option Base URL éditable * La Base URL s'arrête à `/v1`, ne l'écrivez pas en chemin complet `/v1/chat/completions` * Si votre version n'accepte que les modèles officiels intégrés et ne permet pas de modifier la Base URL, la connexion directe à cette passerelle est impossible * En cas d'échec de Verify, vérifiez : la clé ne contient pas d'espaces superflus, le modèle est disponible, le solde du compte est suffisant --- # Droid Source: https://docs.aicentos.com/fr/clients/droid Language: fr > Utiliser aicentos dans Factory Droid : enregistrer des modèles personnalisés dans settings.json (BYOK) Droid est l'agent de codage en ligne de commande de Factory. Il prend en charge le BYOK : enregistrez un modèle personnalisé dans `~/.factory/settings.json` et pointez `baseUrl` vers aicentos. Droid exige une fenêtre de contexte d'au moins 64k pour les modèles ; gardez-le à l'esprit au moment de choisir. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour Droid (nommez-la par exemple `droid`, pour suivre plus facilement sa consommation) : * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger en cas de solde insuffisant : [https://aicentos.com/wallet](https://aicentos.com/wallet) ## Configuration à renseigner | Champ | Valeur | | ------------------------ | ------------------------------------------------------------------- | | Fichier de configuration | `~/.factory/settings.json` | | provider | `generic-chat-completion-api` | | baseUrl | `https://aicentos.com/v1` | | apiKey | `${AICENTOS_API_KEY}` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration ### 1. Définir la variable d'environnement de la clé API ```bash export AICENTOS_API_KEY="sk-votre-clé-API" ``` Écrivez-la dans `~/.zshrc` ou `~/.bashrc` pour un effet permanent. ### 2. Éditer settings.json Éditez `~/.factory/settings.json` et ajoutez le tableau `customModels` : ```json { "customModels": [ { "model": "gpt-4o", "displayName": "GPT-4o (aicentos)", "baseUrl": "https://aicentos.com/v1", "apiKey": "${AICENTOS_API_KEY}", "provider": "generic-chat-completion-api", "maxOutputTokens": 8192 } ] } ``` Champs clés : | Champ | Description | | ------------- | --------------------------------------------------------------------------------------------------------------------------------- | | `model` | Identifiant de modèle réellement envoyé au point d'accès, à faire correspondre à la « place de marché des modèles » de la console | | `displayName` | Nom d'affichage dans le sélecteur de modèles, personnalisable | | `baseUrl` | Adresse API, `/v1` conseillé | | `apiKey` | Prend en charge l'expansion `${VAR_NAME}` | | `provider` | `anthropic` / `openai` / `generic-chat-completion-api` | ### 3. Choisir le modèle Après avoir lancé `droid`, exécutez `/model` et sélectionnez le modèle que vous venez d'enregistrer. **Après toute modification de la configuration, `droid` doit être redémarré dans un nouveau terminal** pour relire le fichier. ## Test Une fois le modèle sélectionné, envoyez une requête simple : ``` Réponds en une phrase : combien font 1+1 ? ``` Une réponse normale signifie que la connexion fonctionne. ## Remarques * **Mettez `generic-chat-completion-api` dans `provider`** : ce mode passe par le protocole OpenAI Chat Completions et c'est le bon choix dans la plupart des scénarios BYOK. Avec `openai`, c'est l'API Responses qui est utilisée, et sur certaines passerelles cette valeur ignore `base_url` et pointe directement vers `api.openai.com` ; avec `anthropic`, c'est `/v1/messages` qui est utilisé. * **Nettoyez d'abord les variables d'environnement**. Si le shell exporte `ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_BASE_URL` ou `ANTHROPIC_API_KEY`, elles prennent le pas sur le fichier de configuration et les requêtes contournent la passerelle que vous avez configurée. Avant la connexion, faites un `unset` de ces variables. * Droid lit à la fois `~/.factory/settings.json` et l'ancien `~/.factory/config.json`, le premier ayant la priorité. Dans l'ancien format, les champs sont en snake\_case : `custom_models` / `model_display_name` / `base_url` / `api_key`, et l'expansion `${VAR_NAME}` **n'est pas prise en charge** ; préférez systématiquement `settings.json`. * La fenêtre de contexte du modèle doit faire au moins 64k ; un modèle local trop petit peut se comporter de façon erratique. * Factory ne teste en référence que les interfaces officielles Anthropic / OpenAI ; la compatibilité des modèles personnalisés n'est pas garantie. Il est connu que les sous-agents (subagent) retombent parfois sur l'interface officielle Anthropic. * Ordre de dépannage : le modèle est-il visible dans `/model` → les variables d'environnement sont-elles écrasées par des ANTHROPIC\_\* → le baseUrl contient-il `/v1` → le solde est-il suffisant ? ## Liens utiles * Documentation BYOK officielle : [https://docs.factory.ai/model-independence/byok](https://docs.factory.ai/model-independence/byok) --- # DSH 大肥魚 Source: https://docs.aicentos.com/fr/clients/dsh Language: fr > Connecter les modèles aicentos à DeepSeek Harness (DSH), élever un poisson qui parcourt Bilibili et Douyin, puis l'inviter dans un groupe QQ DSH (DeepSeek Harness) est le framework d'Agent open source de DeepSeek. L'édition bureau, DSH Desktop, regroupe le runtime, les plugins et les sessions dans un seul installateur. « 大肥魚 » (le gros poisson) est un plugin communautaire nommé `dsh-bili-whale` : un poisson IA qui se réveille selon son propre rythme, parcourt Bilibili, comprend réellement les vidéos, tient deux journaux et vous mentionne celles qui valent le détour. Cette page se divise en quatre parties : connecter DSH à aicentos, élever le poisson Bilibili, passer à la version Douyin, puis le relier aux messages privés et aux groupes QQ via le plugin officiel. Les plugins sont maintenus par la communauté et par Tencent, sans lien avec Bilibili, Douyin ou DeepSeek. ## Prérequis | Élément | Exigence | Remarque | | ---------------- | ---------- | ----------------------------------------------------------------------------------------------------------------------------- | | DSH Desktop | Requis | Installeur macOS / Windows depuis le site officiel ; le runtime est inclus | | Node.js | 18+ | Nécessaire uniquement pour lancer DSH en ligne de commande ; la chaîne d'outils du plugin est en `.mjs` et exige un vrai node | | ffmpeg | Facultatif | Utilisé seulement pour l'extraction d'images ; sans lui, sous-titres, danmaku et commentaires populaires suffisent | | Compte Bilibili | Un | Le compte utilisé par le poisson lui-même, pour lire les cookies ; un compte secondaire est recommandé | | Clé API aicentos | Une | Créez une clé dédiée (nommée `dsh`) pour suivre la consommation par projet | * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) ## Configuration à renseigner | Champ | Valeur | | ------------ | ------------------------------------------------------- | | Provider ID | `aicentos` | | Display name | `aicentos` | | Base URL | `https://aicentos.com/v1` | | API protocol | `openai-completions` | | API Key | La clé créée dans la console | | Model | Un nom de modèle de la Galerie de modèles de la console | ## Étapes de configuration ### Installer DSH Desktop Ouvrez [https://www.dshdesktop.com/](https://www.dshdesktop.com/) et choisissez l'installeur correspondant à votre système (Windows, macOS puce Apple, macOS Intel), puis double-cliquez pour installer. Au premier lancement, suivez le guide : configurez un modèle, créez une session et vérifiez qu'il répond. ### Connecter aicentos dans DSH La configuration par l'interface est recommandée : 1. Ouvrez **Settings → Models** et cliquez sur **Add a custom provider**. 2. Renseignez Provider ID, Display name, Base URL, API protocol et API Key selon le tableau ci-dessus. 3. Dans **Model catalog**, cliquez sur **Fetch available models** et cochez les modèles souhaités ; en cas d'échec, saisissez l'ID du modèle à la main. 4. Cliquez sur **Save**, revenez à la conversation et sélectionnez le modèle dans le sélecteur en haut. Vous pouvez aussi modifier directement `~/.dsh/settings.yaml` : ```yaml agent-default-model: provider: aicentos model: 你的模型名 llm-pi-ai: providers: aicentos: api: openai-completions baseURL: https://aicentos.com/v1 apiKeyEnv: AICENTOS_API_KEY models: - id: 你的模型名 ``` Exportez ensuite la variable et démarrez : ```bash export AICENTOS_API_KEY="sk-你的-API-Key" ``` La clé API est stockée localement dans `$DSH_HOME/.credentials.yaml` ; l'interface ne l'affiche jamais en clair. ### Installer le plugin du poisson Aucun clone manuel : envoyez simplement une ligne dans la conversation DSH : ```bash 帮我安装这个插件，插件地址：https://github.com/Alterssss/dsh-bili-whale ``` Une fois terminé, rechargez la page DSH et ouvrez **Settings → Élever un poisson** (养鱼) dans la barre latérale. Si cette entrée n'apparaît pas, quittez complètement DSH puis relancez-le : les plugins sont assemblés au démarrage, ne pas redémarrer revient à ne pas avoir installé. ### Accorder les permissions complètes à la session C'est l'étape la plus souvent oubliée. Sa session se trouve dans **Espace de travail → Non classés** à gauche (invisible sans déplier ce dossier). Ouvrez la session et passez les permissions sur **Accès complet** (`danger-full-access`), sinon elle ne pourra ni exécuter de commandes, ni publier de commentaires, ni écrire ses journaux après son réveil. ### Connecter le compte Bilibili Dans **Settings → Élever un poisson → Connexion Bilibili**, cliquez sur **Se connecter par QR code** et validez avec l'application Bilibili sur votre téléphone. Le QR code est valable environ 3 minutes ; une annulation ou une expiration ne remplace jamais la session existante. Vous pouvez aussi coller les cookies manuellement : connectez-vous dans un navigateur avec le compte du poisson, appuyez sur F12, ouvrez **Application → Cookies → `https://www.bilibili.com`**, copiez `SESSDATA`, `bili_jct` et `buvid3`, collez-les un par un, puis cliquez sur **Écrire les identifiants**. Ne lisez pas les cookies avec `document.cookie`. `SESSDATA` est HttpOnly et illisible depuis un script ; vous obtiendriez un cookie incomplet et le contrôle de santé resterait bloqué. ### Lancer le contrôle des dépendances Cliquez sur **Contrôle des dépendances** dans la page de réglages. Il envoie une vraie requête à Bilibili pour valider la connexion, puis vérifie cookies, ffmpeg, Node, le répertoire de données et le rythme de vie, point par point. Tout doit être au vert (« tout disponible ✓ »). S'il signale ffmpeg manquant, ne cherchez pas un tutoriel : envoyez « installe ffmpeg sur cet ordinateur » dans la conversation DSH et laissez-le faire, puis relancez le contrôle. Cliquez toujours sur **Enregistrer** après modification. Les champs sont modifiés localement et ne sont écrits sur le disque qu'à l'enregistrement ; la page vous le rappelle. L'enregistrement s'applique immédiatement ; seul un changement de code ou de version du plugin impose de redémarrer DSH. ### Définir la personnalité et le rythme * **Qui elle est** : nom du personnage, comment elle vous appelle, comment elle se désigne. * **Sa personnalité** : le texte est écrit dans `~/.bili-ai/persona.md` ; cliquez sur **Injecter la personnalité** (limite 20000 caractères, seuls les 3000 premiers sont injectés, joints à chaque réveil et écoute). * **Vous (propriétaire)** : renseignez votre `mid` ; les mentions et les messages privés s'appuient dessus. * **Mode de partage** : mention dans les commentaires, ou message privé Bilibili. * **Plage horaire** : par défaut 20:00–24:00 ; elle se réveille à un moment aléatoire dans cette plage, jamais à l'heure pile. Le plugin n'embarque aucune personnalité : par défaut c'est un assistant neutre qui ne vous appelle pas « maître » et ne minaude pas. Pour en faire « 大肥魚 », précisez son identité et son origine, son ton, ce qui la préoccupe et ce qu'elle ne doit pas faire. ## Test Lancez d'abord l'auto-test en ligne de commande : il vérifie configuration, identifiants, session, répertoire de données et dépendances en une passe. ```bash node ~/.dsh/plugins/dsh-bili-whale/tools/bili.mjs selftest ``` Sous Windows, remplacez le chemin par `%USERPROFILE%\.dsh\plugins\dsh-bili-whale\tools\bili.mjs` : ```powershell node "$env:USERPROFILE\.dsh\plugins\dsh-bili-whale\tools\bili.mjs" selftest ``` Toutes les lignes cochées et le message final « 全部通过 ✓ 可以用了 » signifient que tout est prêt. Commandes courantes : ```bash node ~/.dsh/plugins/dsh-bili-whale/tools/bili.mjs deps # contrôle des dépendances node ~/.dsh/plugins/dsh-bili-whale/tools/bili.mjs dm --status # quota de MP + suivi mutuel node ~/.dsh/plugins/dsh-bili-whale/tools/bili.mjs traffic status # valeurs de protection des requêtes ``` Pour la voir tourner tout de suite, réglez la plage horaire sur un créneau de deux minutes à partir de maintenant, enregistrez, puis attendez son réveil (contrôle → sélection → compréhension → rédaction des deux journaux → notification). Vous pouvez aussi lui demander dans la conversation de se réveiller et de parcourir Bilibili une fois. Revenez enfin sur la page d'utilisation de la console aicentos pour vérifier que les requêtes sont bien imputées à la clé créée pour DSH. ## Connecter Douyin La version Douyin est un autre projet reposant sur la même idée : `dsh-douyin-scroll`. Il ne regarde jamais l'image — il lit les légendes, les tags, l'auteur, la durée, les métriques d'engagement et les meilleurs commentaires, sélectionne quelques vidéos par jour et rédige un rapport Markdown. ### Installation ```bash git clone https://github.com/NEWJO123/dsh-douyin-scroll.git cd dsh-douyin-scroll node selfcheck.mjs ``` Une fois la pré-vérification au vert, installez-le dans le profil `web` et redémarrez DSH une fois : ```bash dsh plugin --profile web add "link:$PWD" ``` Après le redémarrage, ouvrez **Settings → Parcourir Douyin** (刷抖音). ### Première configuration 1. Cliquez sur **Installer les dépendances principales** : un venv dédié est créé avec `curl_cffi` et `httpx` (environ 30 secondes, suivi dans `install.log`). 2. Connexion : lancez `node tools/qr-login.mjs start` et scannez, ou collez dans la page de réglages les cookies d'une session Douyin déjà connectée dans le navigateur. 3. Définissez quoi parcourir : mots-clés, catégories, auteurs précis, vidéos par jour, candidats par tour, puis cliquez sur **Lancer un tour maintenant**. Les cookies restent sur la machine dans `$DSH_HOME/douyin-duty/douyin_cookie.txt`, n'apparaissent jamais dans les journaux et ne sont jamais téléversés. ### Capacités et limites | Élément | Détail | | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Critères de jugement | Légendes, tags, auteur, durée, ratios d'engagement, meilleurs commentaires ; aucune image, aucune reconnaissance vocale | | Source des candidats | Flux de recommandation en lecture seule et classement des tendances ; le web de Douyin n'offre pas d'API de recherche utilisable, les mots-clés ne servent que d'annotation | | Rapport | Écrit dans `out/.md` ; notification Windows ou webhook en option | | Envoi | Messages privés, cartes de partage et commentaires désactivés par défaut, chacun exige `confirm` | | Groupes | L'auteur observe que les messages « peuvent ne pas partir en groupe » ; un autre compte peut se comporter différemment | Les URL en texte brut ne sont pas cliquables dans Douyin, seules les cartes de partage le sont. Messages privés, cartes et commentaires nécessitent Chrome (recherche `chrome.exe` uniquement, pas Edge) ; la collecte et le rapport n'en ont pas besoin. Commenter fréquemment déclenche une limitation, et la précision est inférieure à la version Bilibili : sans sous-titres, il ne lit que les réactions du public. ## Connecter un groupe QQ QQ Bot dispose d'un plugin officiel, `@tencent-connect/dsh-qqbot`, installé dans un profil `qqbot` dédié. Après appairage par QR code, il dialogue dans les messages privés et les groupes QQ. ```bash npx @deepseek-ai/dsh plugin --profile qqbot add @tencent-connect/dsh-qqbot npx @deepseek-ai/dsh --profile qqbot ``` Au premier lancement, scannez le QR code comme indiqué ; aucune clé à saisir manuellement. Une fois appairé : * **Sessions isolées** : chaque message privé et chaque groupe possède son propre contexte, sans mélange, et les sessions sont restaurées après redémarrage. * **Changement de modèle dans le chat** : le basculement conserve le contexte existant, sans repartir de zéro. * **Mode discret** : configurez-le pour ne répondre que lorsqu'il est mentionné, afin de ne pas inonder le groupe. Le modèle se configure dans le profil `qqbot` : ouvrez-y **Settings → Models → Add a custom provider** et renseignez aicentos selon le tableau ci-dessus. Pour gérer plusieurs canaux de messagerie au même endroit, regardez le bundle communautaire `dsh-im`, qui couvre dix canaux avec plusieurs bots et des réponses en streaming. Les conversations du groupe sont lues dans le contexte et transmises au modèle : ne lui faites pas manipuler de comptes ou de clés dans un groupe. Les identifiants d'appairage restent dans le profil local, ne synchronisez jamais ce répertoire vers un dépôt public. ## Compagnon de bureau et nettoyage des commentaires Deux plugins facultatifs, projets distincts du poisson : | Usage | Projet | Installation | | ------------------------------------------------------- | -------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Un poisson animé sur le bureau | [https://github.com/QCYTSN/dsh-dafeiyu](https://github.com/QCYTSN/dsh-dafeiyu) | Envoyez l'URL à DSH pour qu'il l'installe ; une fenêtre native transparente apparaît, déplaçable, animée selon l'état des tâches | | Masquer les comptes suspects d'IA dans les commentaires | [https://github.com/liyupi/dafeiyu-cleaner](https://github.com/liyupi/dafeiyu-cleaner) | Extension navigateur : téléchargez le zip dans Releases, décompressez, ouvrez `chrome://extensions`, activez le mode développeur et chargez l'extension non empaquetée | L'extension de nettoyage masque seulement les commentaires dans votre navigateur : elle ne supprime rien, ne signale jamais automatiquement et permet de rétablir un compte mal jugé. Sa détection hors ligne atteint environ 85 %, un chiffre mesuré dans une seule section de commentaires et qui ne se vérifie pas forcément ailleurs. ## Remarques * **Laissez les commentaires automatiques désactivés au début.** Ils sont désactivés par défaut ; une fois activés, un seul commentaire par tour, 20 au maximum, et une seule fois par vidéo. Malgré cela, un déferlement public devient une « invasion de poissons » pour les autres. Commencez par des messages privés Bilibili vers vous-même. * **Le canal des messages privés exige deux comptes.** Choisir le message privé Bilibili suppose deux comptes distincts qui se suivent mutuellement (`relation.attribute === 6`). Avec un seul compte, regarder des vidéos, écrire les journaux et générer des rapports fonctionnent ; les messages privés non. * **Autorisez avec un compte secondaire.** Le plugin parle avec votre propre compte : ne confiez pas les cookies de votre compte principal à un plugin tiers et n'achetez jamais de comptes d'origine inconnue. * **Arrêtez en cas de limitation.** Sur 412 / 429, captcha ou bridage, le plugin se met en pause 5 à 30 minutes et le signale ; ne réessayez pas en boucle, les endpoints signés ne garantissent pas de contourner les limites de la plateforme. * **Choisissez un modèle économique.** Elle sélectionne 5 vidéos, en lit 2 à 3 en profondeur et écrit deux journaux chaque jour, soit de nombreuses requêtes par tour. Prenez un modèle peu coûteux avec assez de contexte dans aicentos (voir [modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list)) et créez une clé dédiée à DSH pour suivre le coût. * **Le mode sans interface ne fonctionne pas.** Le plugin doit tourner sur un DSH doté de l'interface web, sinon il reste bloqué sur `pending (waiting for services: sessionController, webServer, connection)`. * Le plugin est la version publique d'un outil personnel, sans lien avec Bilibili ou DeepSeek ; vous agissez avec votre propre compte et à vos risques, dans le respect des règles de la plateforme. ## Liens utiles * [Dépôt du plugin dsh-bili-whale](https://github.com/Alterssss/dsh-bili-whale) * [Dépôt du plugin dsh-douyin-scroll](https://github.com/NEWJO123/dsh-douyin-scroll) * [Documentation officielle des bots QQ](https://bot.qq.com/wiki/agent-qqbot/) * [Site officiel de DSH Desktop](https://www.dshdesktop.com/) * [Code source de DSH Desktop](https://github.com/dataelement/dsh-desktop) * [Journal des modifications du plugin](https://github.com/Alterssss/dsh-bili-whale/blob/main/CHANGELOG.md) * [Modèles pris en charge par aicentos](https://docs.aicentos.com/fr/billing/models-list) --- # Freebuff Source: https://docs.aicentos.com/fr/clients/freebuff Language: fr > Freebuff ne demande pas de clé API et n'offre aucune configuration de point d'accès personnalisé — raisons et alternatives L'argument de Freebuff est « pas d'abonnement, pas de crédits, pas de clé API » : les modèles viennent d'un catalogue intégré et le coût est supporté par son propre système de comptes. Il **n'a donc aucun champ de configuration Base URL ou de clé**, et ne peut pas se connecter à aicentos. ## Pourquoi une connexion directe est impossible Le README officiel indique explicitement `No subscription, credits, or API key required`, et la configuration ne contient aucun champ du type `baseUrl` ou `apiKey`. Sa version de bureau peut héberger un Claude Code ou un Codex déjà installé localement et réutiliser le compte provider de ces outils — mais c'est le **CLI hébergé** qui choisit le modèle, pas la configuration de modèles de Freebuff. Pour emprunter cette voie vers aicentos, configurez-le dans le CLI hébergé (voir [Claude Code](https://docs.aicentos.com/fr/clients/claude-code), [Codex CLI](https://docs.aicentos.com/fr/clients/codex-cli)). ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | API Key | clé créée dans la console | | Base URL | `https://aicentos.com/v1` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | Le tableau ci-dessus regroupe les paramètres génériques côté aicentos, utilisables par les alternatives ci-dessous. ## Alternatives * Pour un agent de codage en terminal : [Craft Agent](https://docs.aicentos.com/fr/clients/craft-agent), [Gajae Code](https://docs.aicentos.com/fr/clients/gajae-code), [Oh My Pi](https://docs.aicentos.com/fr/clients/oh-my-pi). * Pour d'abord tester avec des crédits gratuits : utilisez les crédits d'essai de la console, confirmez que le modèle convient, puis passez à un client acceptant un endpoint personnalisé. * Si vous voulez seulement utiliser sa coque de bureau pour héberger un autre CLI : configurez aicentos du côté de Claude Code / Codex CLI, c'est suffisant. ## Test Après être passé à l'un des clients alternatifs, envoyez une invite pour confirmer la connectivité, puis retournez dans la console vérifier la consommation. ## Remarques * « Gratuit » signifie que le modèle n'est pas sélectionnable et que le fournisseur ne peut pas être changé : ne cherchez pas de réglages en partant du principe que c'est « configurable ». * La documentation officielle mentionne un débit limité dans certaines régions restreintes ou lorsqu'un VPN est activé. ## Liens utiles * [Freebuff CLI](https://freebuff.com/cli) * [Dépôt freebuff](https://github.com/CodebuffAI/freebuff) --- # Fx Source: https://docs.aicentos.com/fr/clients/fx Language: fr > Utiliser aicentos dans Fx : ajouter une connexion de modèle personnalisée dans le settings.json utilisateur Fx est l'agent de codage de Vercel Labs, compilé en un unique binaire natif écrit en Zig, indépendant des modèles. Les connexions de modèles personnalisées se définissent dans le fichier utilisateur `~/.fx/settings.json`, en pointant la base URL vers aicentos. **Un piège à connaître d'emblée :** le `.fx.json` à la racine du projet est une autre affaire. Il interdit délibérément la plupart des champs (modèle compris), afin d'empêcher un dépôt cloné de remplacer votre modèle ou votre point d'accès. **Une connexion de point d'accès personnalisé doit impérativement s'écrire dans `~/.fx/settings.json`** ; dans `.fx.json`, elle n'aurait aucun effet. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour Fx (nommez-la par exemple `fx`, pour suivre plus facilement sa consommation) : * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger en cas de solde insuffisant : [https://aicentos.com/wallet](https://aicentos.com/wallet) Vérifiez que Fx est installé : ```bash curl -fsSL https://fx.sh/setup.sh | bash fx --version ``` ## Configuration à renseigner | Champ | Valeur | | ------------------------ | ------------------------------------------------------------------- | | Fichier de configuration | `~/.fx/settings.json` | | Base URL | `https://aicentos.com/v1` | | API Key | La clé créée dans la console | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration ### 1. Éditer les réglages utilisateur Dans `~/.fx/settings.json`, enregistrez une connexion au format « connexion de modèle personnalisée ». La structure des champs de l'objet de connexion fait foi dans la documentation officielle : * Entrée de la documentation : [https://fx.sh/docs](https://fx.sh/docs) * README : [https://github.com/vercel-labs/fx](https://github.com/vercel-labs/fx) Renseignez l'adresse API de la connexion ainsi : ``` https://aicentos.com/v1 ``` Pour l'API Key, utilisez la clé créée dans la console ; pour les noms de modèles, référez-vous à la « place de marché des modèles » de la console. ### 2. Désigner cette connexion Fx permet de préciser provider et modèle au lancement : ```bash fx provider local FX_MODEL=gpt-4o fx ask "Réponds en une phrase : combien font 1+1 ?" ``` Ou via une variable d'environnement : ```bash export FX_MODEL="gpt-4o" ``` ### 3. Vérifier le provider actuel Fx mémorise le choix par provider : au prochain démarrage, il reprend le provider précédent. ## Test Commencez par vérifier la connectivité avec un prompt sans effet de bord : ```bash fx ask "Réponds en une phrase : combien font 1+1 ?" ``` Une réponse normale signifie que la connexion fonctionne. En cas d'erreur d'authentification, vérifiez d'abord que la base URL contient bien `/v1` et que l'API Key ne comporte pas d'espace parasite. ## Remarques * **Ne modifiez pas `.fx.json`**. Le fichier de projet n'accepte que quelques champs comme `provider_order` ou `provider_strict`, sans champ `model`, et ne sert pas à configurer un point d'accès personnalisé. * `provider_order` / `provider_strict` sont des paramètres de routage du Vercel AI Gateway : **ils ne s'appliquent qu'aux requêtes vers le Gateway et sont ignorés par les connexions de modèles personnalisées** ; ne comptez pas sur eux pour changer d'amont. * La prise en charge officielle des connexions de modèles personnalisées évolue encore ; sur les premières versions, une build récente peut être nécessaire pour la reconnaissance. Après une mise à jour, relancez d'abord la commande de test ci-dessus avant un usage sérieux. * Le script d'installation du binaire télécharge depuis le réseau ; vérifiez vous-même la fiabilité de la source avant de l'exécuter. ## Liens utiles * Page du projet : [https://github.com/vercel-labs/fx](https://github.com/vercel-labs/fx) --- # Gajae Code Source: https://docs.aicentos.com/fr/clients/gajae-code Language: fr > Connecter aicentos à Gajae Code (gjc) — ajouter un provider compatible OpenAI dans models.yml Les providers de Gajae Code sont définis dans `~/.gjc/agent/models.yml`, avec les champs `baseUrl` / `api` / `apiKey` : il suffit d'ajouter un bloc pour pointer vers aicentos. ## Prérequis Créez d'abord dans la console une clé dédiée pour Gajae Code (nommez-la par exemple `gajae-code`), puis installez le CLI : ```bash curl -fsSL https://raw.githubusercontent.com/Yeachan-Heo/gajae-code/v0.15.3/scripts/install.sh -o gjc-install.sh sh gjc-install.sh gjc --version ``` ## Configuration à renseigner | Champ | Valeur | | ----------------------- | ------------------------------------------------------------------- | | Nom du provider | au choix, par exemple `aicentos` | | `baseUrl` | `https://aicentos.com/v1` | | `api` | `openai-completions` | | `apiKey` ou `apiKeyEnv` | la clé directement, ou le nom de la variable d'environnement | | `models[].id` | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration Modifiez `~/.gjc/agent/models.yml` : ```yaml providers: aicentos: baseUrl: https://aicentos.com/v1 api: openai-completions apiKeyEnv: AICENTOS_API_KEY discovery: type: openai-models-list models: - id: votre-nom-de-modèle contextWindow: 128000 maxTokens: 8192 ``` Faites pointer le modèle par défaut dessus : ```yaml modelBindings: modelRoles: default: aicentos/votre-nom-de-modèle:high ``` Exportez ensuite la clé avant de lancer : ```bash export AICENTOS_API_KEY="sk-votre-clé-API" gjc ``` La section `discovery` lui permet de récupérer automatiquement la liste des modèles ; si vous préférez contrôler manuellement les modèles visibles, supprimez cette section et ne gardez que `models`. ## Test Lancez `gjc` et vérifiez dans le sélecteur de modèles que les modèles sous `aicentos` apparaissent, puis envoyez une invite pour confirmer que la réponse arrive. Si la liste est vide, vérifiez d'abord l'indentation de `models.yml` et la section `discovery`. ## Remarques * `models.yml` est validé strictement : tout champ inconnu provoque une erreur. Ne recopiez pas les notations à underscore `api_key` ou `base_url` d'autres outils ; ici, il faut le camelCase `baseUrl` et `apiKey`. * Renseignez `contextWindow` et `maxTokens` selon le modèle réel ; des valeurs trop grandes seront rejetées en amont. * Dans `modelRoles.default`, `:high` est un suffixe d'intensité de raisonnement ; modifiez-le selon vos besoins ou supprimez-le. * Le projet se décrit comme experimental : les champs peuvent changer après une mise à niveau, référez-vous au fichier `docs/models.md` du dépôt. ## Liens utiles * [Dépôt gajae-code](https://github.com/Yeachan-Heo/gajae-code) --- # Gemini CLI Source: https://docs.aicentos.com/fr/clients/gemini-cli Language: fr > Utiliser aicentos dans Gemini CLI : configurer une passerelle personnalisée via des variables d'environnement Gemini CLI est l'outil en ligne de commande officiel de Google. Il permet de configurer une passerelle personnalisée via des variables d'environnement pour se connecter au service Codex Proxy et dialoguer avec les modèles Gemini depuis le terminal. ## Prérequis Gemini CLI s'installe globalement via npm ; préparez d'abord un environnement Node.js 18 ou supérieur avec npm. ### Installation de Node.js * Page de téléchargement du site officiel de Node.js : [https://nodejs.org/en/download](https://nodejs.org/en/download) * macOS/Windows : téléchargez et installez la version LTS * Linux : installez selon la méthode propre à votre distribution, indiquée sur cette page * macOS (utilisateurs de Homebrew) : exécutez `brew install node` ### Vérification de l'installation ```bash node -v npm -v ``` ## Installation de Gemini CLI Installez Gemini CLI globalement via npm : ```bash npm install -g @google/gemini-cli ``` Vérifiez l'installation : ```bash gemini --version ``` ## Configuration des variables d'environnement Gemini CLI prend en charge la connexion à une passerelle personnalisée via les trois variables d'environnement suivantes : | Variable d'environnement | Description | | ------------------------ | --------------------------------------------------------------------------------------- | | `GOOGLE_GEMINI_BASE_URL` | Adresse racine du service de passerelle, remplace le point d'accès par défaut de Google | | `GEMINI_API_KEY` | Votre clé API | | `GEMINI_MODEL` | Modèle utilisé par défaut | ### Exemple de configuration ```bash export GOOGLE_GEMINI_BASE_URL="https://aicentos.com" export GEMINI_API_KEY="your_api_key_here" export GEMINI_MODEL="gemini-2.0-flash" ``` ### Points d'attention * `GOOGLE_GEMINI_BASE_URL` reçoit l'adresse racine du service, sans chemin d'interface spécifique * Test ponctuel : exécutez les commandes export ci-dessus directement dans la session de shell courante * Effet permanent : ajoutez les lignes export à `~/.zshrc` ou `~/.bashrc`, puis exécutez `source ~/.zshrc` pour les appliquer ## Démarrage de Gemini CLI Une fois la configuration terminée, lancez simplement : ```bash gemini ``` Vous pouvez ensuite dialoguer avec les modèles Gemini depuis le terminal. ## Vérification de la connexion Engagez une conversation dans Gemini CLI ; si vous recevez une réponse normalement, la connexion fonctionne. ### Dépannage des problèmes courants * En cas d'erreur d'authentification, vérifiez que `GEMINI_API_KEY` est correcte * Vérifiez que `GOOGLE_GEMINI_BASE_URL` pointe vers la bonne adresse de service ## Remarques * Le service prend en charge l'interface compatible Gemini et peut donc être utilisé directement avec Gemini CLI * Il est conseillé d'ajouter la configuration des variables d'environnement au fichier de configuration du shell pour un effet permanent * Gemini CLI construit lui-même les chemins d'API ; n'ajoutez pas de chemin d'interface spécifique dans la BASE\_URL ## Liens utiles * Documentation officielle : [https://docs.aicentos.com/clients/gemini-cli.html](https://docs.aicentos.com/clients/gemini-cli.html) --- # Goose Source: https://docs.aicentos.com/fr/clients/goose Language: fr > Utiliser aicentos dans Goose : déclarer un provider personnalisé compatible OpenAI Goose est l'agent de codage open source de Block. Deux approches permettent de pointer vers un point d'accès compatible OpenAI : réutiliser le provider `openai` intégré en changeant son host, ou déclarer un provider personnalisé indépendant. La seconde est recommandée : les informations du point d'accès y sont plus centralisées et il est plus facile de conserver plusieurs configurations en parallèle. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour Goose (nommez-la par exemple `goose`, pour suivre plus facilement sa consommation) : * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger en cas de solde insuffisant : [https://aicentos.com/wallet](https://aicentos.com/wallet) ## Configuration à renseigner | Champ | Valeur | | -------------------------------- | ------------------------------------------------------------------- | | Fichier du provider personnalisé | `~/.config/goose/custom_providers/aicentos.json` | | engine | `openai` | | base\_url | `https://aicentos.com/v1/chat/completions` | | api\_key\_env | `AICENTOS_API_KEY` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration ### 1. Définir la variable d'environnement de la clé API ```bash export AICENTOS_API_KEY="sk-votre-clé-API" ``` Écrivez-la dans `~/.zshrc` ou `~/.bashrc` pour un effet permanent. **N'écrivez pas la clé dans config.yaml** : l'éditeur recommande explicitement une variable d'environnement ou le trousseau système. ### 2. Déclarer le provider personnalisé Créez `~/.config/goose/custom_providers/aicentos.json` (sous Windows : `%APPDATA%\Block\goose\config\custom_providers\`) : ```json { "name": "aicentos", "engine": "openai", "display_name": "aicentos", "description": "Modèles exposés par aicentos", "api_key_env": "AICENTOS_API_KEY", "base_url": "https://aicentos.com/v1/chat/completions", "models": [ { "name": "gpt-4o", "context_limit": 128000 } ], "supports_streaming": true, "dynamic_models": true } ``` Les champs obligatoires sont `name`, `engine`, `display_name`, `base_url` et `models` ; `engine` prend les valeurs `openai` / `anthropic` / `ollama`. Les noms de modèles font foi tels qu'affichés dans la « place de marché des modèles » de la console, voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list). ### 3. Définir par défaut dans config.yaml Éditez `~/.config/goose/config.yaml` : ```yaml GOOSE_PROVIDER: aicentos GOOSE_MODEL: gpt-4o ``` Au démarrage, Goose analyse le répertoire `custom_providers/` et enregistre automatiquement les providers ; le basculement reste ensuite possible dans l'interface graphique. ## Test Commencez par une session non interactive : ```bash goose run -t "Réponds en une phrase : combien font 1+1 ?" ``` Une réponse normale signifie que la connexion fonctionne. ## Remarques * **`base_url` doit contenir le chemin complet** (ici avec `/v1/chat/completions`), ce qui diffère de l'usage de la plupart des clients. Pour préciser explicitement le chemin, les versions récentes acceptent aussi un champ `base_path`, prioritaire sur l'analyse de l'URL. * **Les variables d'environnement priment sur config.yaml**. Si `OPENAI_HOST` est exporté dans le shell, il écrase silencieusement la configuration du fichier ; en cas de doute, commencez par `env | grep -i openai`. * Goose ne démarre correctement que si un provider est sélectionné. Si vous avez écrit la configuration dans `config.yaml` sans jamais exécuter `goose configure`, vous risquez un `No provider configured` — erreur fréquente : les clés de configuration sont au format YAML, pas dans un `.env`. * Avec `dynamic_models: true`, Goose interroge le `/v1/models` du point d'accès pour récupérer la liste des modèles ; pour n'exposer que certains modèles, supprimez ce champ ou passez-le à `false`. * Autre approche simplifiée : réutiliser le provider intégré en posant `GOOSE_PROVIDER: openai` dans config.yaml, puis composer le point d'accès avec `OPENAI_HOST` et `OPENAI_BASE_PATH`. Plus rapide à mettre en œuvre, mais davantage couplée aux variables d'environnement et donc plus exposée au problème d'écrasement évoqué plus haut. * Ordre de dépannage : le nom du provider correspond-il exactement au nom du fichier JSON → `base_url` contient-il le chemin complet → les variables d'environnement sont-elles visibles → le solde est-il suffisant ? ## Liens utiles * Documentation des providers personnalisés : [https://block.github.io/goose/docs/api/providers/custom](https://block.github.io/goose/docs/api/providers/custom) --- # Grok Build Source: https://docs.aicentos.com/fr/clients/grok-build Language: fr > Connecter aicentos à Grok Build : model provider personnalisé via config.toml Grok Build est l'agent de programmation en terminal de xAI ; il appelle par défaut l'interface officielle xAI, mais il permet de déclarer dans `~/.grok/config.toml` n'importe quel point de terminaison compatible OpenAI sous la forme `[model.*]`. Pointez le point de terminaison vers aicentos pour appeler, avec la même clé, les modèles de la famille grok comme ceux des autres fournisseurs. ## Prérequis * Installez Grok Build (script officiel) : ```bash curl -fsSL https://x.ai/cli/install.sh | bash ``` * Créez une clé dédiée dans la console aicentos (nommez-la par exemple `grok-build`). ## Configuration à renseigner | Champ | Valeur | | --------------- | --------------------------------------------------------------------------------------------------------- | | base\_url | `https://aicentos.com/v1` | | api\_backend | `chat_completions` (valeur par défaut) | | env\_key | `AICENTOS_API_KEY` | | model | ID du modèle dans la « place de marché des modèles » de la console, par ex. `grok-4.7`, `claude-opus-4-8` | | context\_window | selon le modèle choisi, par ex. `200000` | ## Étapes de configuration * Écrivez la clé dans les variables d'environnement du shell (dans `~/.zshrc` ou `~/.bashrc`, puis `source` pour l'appliquer) : ```bash export AICENTOS_API_KEY="your_api_key_here" ``` * Éditez `~/.grok/config.toml` en ajoutant un modèle personnalisé : ```toml [models] default = "aicentos-grok" [model.aicentos-grok] base_url = "https://aicentos.com/v1" env_key = "AICENTOS_API_KEY" api_backend = "chat_completions" context_window = 200000 max_completion_tokens = 8192 description = "aicentos gateway - grok-4.7" ``` Le `` de `[model.]` est l'ID du modèle ; pour intégrer plusieurs modèles, par exemple `grok-4.7` et `claude-opus-4-8`, ajoutez respectivement un bloc `[model.grok-4.7]` et `[model.claude-opus-4-8]`. * Lancez Grok Build, puis basculez avec le sélecteur de modèles ou en commande : ```bash grok /model aicentos-grok ``` ## Test Vérifiez d'abord que les modèles sont reconnus : ```bash grok models ``` Envoyez ensuite une invite légère (par ex. `grok -p "présente le répertoire courant en une phrase" -m aicentos-grok`) pour vérifier que la réponse arrive normalement. ## Remarques * Grok Build n'a **pas de paramètre de ligne de commande `--base-url`** ; le point de terminaison personnalisé ne peut être précisé que par le fichier de configuration ou les variables d'environnement. * `api_backend` vaut `chat_completions` par défaut ; si vous écrivez explicitement `responses` ou `messages`, vérifiez que la passerelle prend en charge le point de terminaison correspondant, sinon l'appel échouera. * L'ordre de résolution des identifiants est : `api_key` dans la configuration du modèle → variable d'environnement désignée par `env_key` → token de la session connectée → `XAI_API_KEY` global. Ici, utilisez `env_key` avec votre propre nom de variable, sans risque de mélange avec le compte officiel xAI. * Si un nouveau modèle omet `context_window`, Grok Build applique par défaut 200 000 ; il est conseillé de le renseigner explicitement selon le modèle choisi. * Une fois le point de terminaison personnalisé en place, l'abonnement xAI n'est plus nécessaire, mais le modèle sélectionné reste facturé côté aicentos ; vérifiez d'abord le solde sur la [page du portefeuille](https://aicentos.com/wallet). --- # Grok CLI Source: https://docs.aicentos.com/fr/clients/grok-cli Language: fr > Utiliser aicentos dans Grok CLI : connexion via des variables d'environnement ou un fichier de configuration Grok CLI est un outil en ligne de commande qui utilise l'interface compatible OpenAI et accepte directement une adresse API personnalisée comme service back-end. ## Prérequis Installez d'abord Node.js 18 ou supérieur et npm. L'installation depuis la page officielle de téléchargement de Node.js est recommandée : [https://nodejs.org/en/download](https://nodejs.org/en/download) * macOS/Windows : téléchargez et installez la version LTS * Linux : installez selon la méthode propre à votre distribution Sous macOS, vous pouvez aussi utiliser Homebrew : ```bash brew install node ``` Une fois l'installation terminée, vérifiez : ```bash node -v npm -v ``` ## Installation de Grok CLI Installation globale via npm : ```bash npm install -g @vibe-kit/grok-cli ``` Une fois l'installation terminée, vérifiez : ```bash grok --version ``` ## Configuration de la connexion Grok CLI propose trois méthodes de configuration, par ordre de priorité : arguments de ligne de commande > variables d'environnement > fichier de configuration. ### Méthode 1 : variables d'environnement (recommandé) Définissez les variables d'environnement suivantes : ```bash export GROK_BASE_URL="https://aicentos.com/v1" export GROK_API_KEY="your_api_key_here" ``` Pour un test ponctuel, un simple `export` dans le shell courant suffit. Pour un effet permanent, ajoutez ces lignes à `~/.zshrc` ou `~/.bashrc`, puis exécutez `source ~/.zshrc` pour les appliquer. ### Méthode 2 : fichier de configuration Éditez `~/.grok/user-settings.json` : ```json { "apiKey": "your_api_key_here", "baseURL": "https://aicentos.com/v1", "defaultModel": "gpt-4o" } ``` ### Méthode 3 : arguments de ligne de commande Précisez au lancement via un argument : ```bash grok --base-url https://aicentos.com/v1 ``` ## Démarrage et utilisation Une fois la configuration terminée, lancez simplement : ```bash grok ``` Engagez une conversation dans Grok CLI ; si vous recevez une réponse normalement, la connexion fonctionne. ## Vérification et dépannage En cas d'erreur d'authentification, vérifiez : * que `GROK_API_KEY` est correcte * que `GROK_BASE_URL` / `baseURL` pointe vers la bonne adresse de service (le suffixe `/v1` est requis) Une fois la configuration corrigée, relancez simplement. ## Remarques * Grok CLI utilise l'interface compatible OpenAI ; la configuration est simple et directe * Les trois méthodes de configuration se choisissent librement ; les variables d'environnement sont recommandées * L'adresse API doit inclure le suffixe `/v1` * Le modèle par défaut est personnalisable ## Liens utiles * Documentation officielle : [https://docs.aicentos.com/clients/grok-cli.html](https://docs.aicentos.com/clients/grok-cli.html) --- # Hermes Agent Source: https://docs.aicentos.com/fr/clients/hermes-agent Language: fr > Utiliser aicentos dans Hermes Agent : désigner un point d'accès compatible OpenAI via des variables d'environnement Hermes Agent lit via des variables d'environnement les informations de connexion au service de modèles. Pointez la Base URL vers aicentos et toutes les requêtes de raisonnement de l'agent passeront par les modèles intégrés par aicentos. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour Hermes Agent (nommez-la par exemple `hermes-agent`, pour suivre plus facilement sa consommation). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) * Site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) ## Configuration à renseigner | Champ | Valeur | | ----------------- | ------------------------------------------------------------------- | | OPENAI\_BASE\_URL | `https://aicentos.com/v1` | | OPENAI\_API\_KEY | clé créée dans la console | | Model | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration Définissez les variables dans le même shell que celui qui lance l'Agent : ```bash export OPENAI_BASE_URL="https://aicentos.com/v1" export OPENAI_API_KEY="sk-votre-clé" export OPENAI_MODEL="gpt-4o" ``` Lancez ensuite Hermes Agent comme d'habitude. Pour un effet permanent, écrivez ces `export` dans `~/.zshrc` ou `~/.bashrc`, puis refaites un `source`. Si Hermes Agent propose son propre fichier de configuration, vous pouvez y renseigner base\_url / api\_key / model de manière équivalente ; en cas de coexistence, sa priorité interne s'applique (en général, les variables d'environnement l'emportent). ## Test Après le démarrage, déclenchez un raisonnement minimal (par exemple demandez-lui de répondre à une question de culture générale) et vérifiez que vous recevez une réponse. Consultez ensuite la page d'usage de la console pour confirmer que la requête est bien comptée sur la clé créée pour Hermes Agent. ## Remarques * Les variables d'environnement doivent être visibles dans la session de shell qui lance l'Agent ; écrites dans un autre shell, elles n'auront aucun effet. * En déploiement Docker, transmettez les variables via `-e` ou le champ `environment` de compose ; les avoir posées uniquement sur l'hôte ne suffit pas. * La Base URL s'arrête à `/v1`. * Certains frameworks d'agent lisent en priorité `OPENAI_API_BASE` ; si les variables ci-dessus ne sont pas prises en compte, ajoutez la variante orthographique équivalente et réessayez. * Créez une clé dédiée pour l'agent afin de suivre plus facilement sa consommation par projet. --- # Hindsight Source: https://docs.aicentos.com/fr/clients/hindsight Language: fr > Configurer les modèles aicentos pour le service de mémoire Hindsight — quatre variables d'environnement suffisent, compatible OpenAI Hindsight est un système de mémoire pour agents open source, qui fournit un service auto-hébergé, des interfaces HTTP / MCP, un SDK et un CLI. Ce n'est pas un client de chat en soi, mais **l'extraction de la mémoire nécessite un LLM**, et ce LLM peut pointer vers aicentos. ## Prérequis Créez d'abord dans la console une clé dédiée pour Hindsight (nommez-la par exemple `hindsight`). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) Le serveur Hindsight nécessite PostgreSQL 14 ou supérieur. Son `pg0` intégré ne convient qu'au développement ; en production, connectez votre propre instance. ```bash pip install hindsight-api ``` ## Configuration à renseigner | Variable d'environnement | Valeur | | ---------------------------- | ------------------------------------------------------------------- | | `HINDSIGHT_API_LLM_PROVIDER` | `openai` | | `HINDSIGHT_API_LLM_BASE_URL` | `https://aicentos.com/v1` | | `HINDSIGHT_API_LLM_API_KEY` | clé créée dans la console | | `HINDSIGHT_API_LLM_MODEL` | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration Il suffit de les écrire dans l'environnement de démarrage, sans modifier le code : ```bash export HINDSIGHT_API_LLM_PROVIDER="openai" export HINDSIGHT_API_LLM_BASE_URL="https://aicentos.com/v1" export HINDSIGHT_API_LLM_API_KEY="sk-votre-clé-API" export HINDSIGHT_API_LLM_MODEL="votre-nom-de-modèle" hindsight-api ``` En déploiement Docker, placez ces variables dans le champ `environment` du compose. À noter : l'image officielle n'inclut pas `llama.cpp`, ne comptez pas faire tourner un modèle local dans le conteneur. ## Test ```bash curl -fsSL https://hindsight.vectorize.io/get-cli | bash hindsight health ``` Une fois le service démarré, écrivez une mémoire puis relisez-la : si l'aller-retour fonctionne, l'appel au LLM est opérationnel. Vous pouvez aussi consulter directement la consommation dans la console : chaque extraction de mémoire par Hindsight génère une requête. ## Remarques * `BASE_URL` doit se terminer par `/v1`, et l'amont doit pouvoir servir `/chat/completions` ; avec `https://aicentos.com`, vous obtiendrez une 404. * Sans clé LLM configurée, le service refuse de démarrer : c'est une validation obligatoire de son côté, pas une clé mal saisie. * L'extraction de mémoire est un traitement par lots en arrière-plan ; la consommation croît avec le nombre de mémoires. Il est conseillé de donner à Hindsight une clé dédiée pour l'observer facilement. * `HINDSIGHT_API_LLM_PROVIDER` à `openai` désigne le protocole compatible OpenAI, et non l'usage exclusif de modèles OpenAI. ## Liens utiles * [Configuration des modèles Hindsight](https://hindsight.vectorize.io/developer/models) * [Dépôt hindsight](https://github.com/vectorize-io/hindsight) --- # Jcode Source: https://docs.aicentos.com/fr/clients/jcode Language: fr > Utiliser aicentos dans Jcode : point de terminaison compatible OpenAI précisé via le fichier de configuration Jcode permet de préciser, via un fichier de configuration, un service API compatible OpenAI. Pointez la Base URL vers aicentos et renseignez l'API Key pour utiliser, dans Jcode, les modèles intégrés par aicentos. ## Prérequis Créez d'abord, sur la page « API Key » de la console, une clé dédiée pour Jcode (nommez-la par exemple `jcode`, pour suivre plus facilement sa consommation). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) * Site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | Provider | OpenAI Compatible | | Base URL | `https://aicentos.com/v1` | | API Key | clé créée dans la console | | Model | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration * Ouvrez le fichier de configuration de Jcode (généralement dans le répertoire de configuration utilisateur, du type `~/.jcode/config.json`). * Ajoutez une entrée de provider compatible OpenAI. * `baseURL` / `baseUrl` : `https://aicentos.com/v1` * `apiKey` : la clé créée dans la console. * `model` : le nom du modèle dans la « place de marché des modèles » de la console (voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list)). * Enregistrez puis redémarrez Jcode pour que la configuration prenne effet. Structure de référence : ```json { "provider": "openai", "baseUrl": "https://aicentos.com/v1", "apiKey": "sk-votre-clé", "model": "gpt-4o" } ``` Si votre version place la configuration dans `~/.config/jcode/config.json`, modifiez le fichier du même nom à cet emplacement. ## Test Après le redémarrage, créez une nouvelle session et envoyez une invite simple ; si la réponse arrive normalement, l'intégration fonctionne. ## Remarques * Le nommage des options de configuration (`baseUrl` / `base_url`) peut varier selon les versions ; référez-vous aux noms de champs du modèle de configuration local. * La Base URL s'arrête à `/v1`, ne la complétez pas en chemin d'interface complet. * Si votre version de Jcode n'offre pas d'entrée de Base URL personnalisée, elle ne peut pas se connecter à un point de terminaison tiers ; passez à un autre client prenant en charge une Base URL personnalisée. * Ne commitez pas la clé dans un dépôt ; référez-la si nécessaire via des variables d'environnement. --- # Junie Source: https://docs.aicentos.com/fr/clients/junie Language: fr > Connecter aicentos à Junie CLI via un profile de modèle personnalisé Junie est l'agent de codage de JetBrains, décliné en plugin IDE et en Junie CLI. **Seul Junie CLI permet de pointer vers un point de terminaison personnalisé** : il s'appuie sur des profiles JSON placés sous `$JUNIE_HOME/models/` pour se connecter à n'importe quel service compatible OpenAI. Le plugin IDE ne peut pas, à ce jour, pointer vers un point de terminaison personnalisé. ## Prérequis Créez d'abord, sur la page « API Key » de la console, une clé dédiée pour Junie (nommez-la par exemple `junie-cli`). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) ## Configuration à renseigner | Champ | Valeur | | ------------------------------ | ------------------------------------------------------------------- | | `baseUrl` | `https://aicentos.com/v1/chat/completions` | | `apiType` | `OpenAICompletion` | | `apiKey` | clé créée dans la console (référence `${ENV_VAR}` prise en charge) | | `id` | nom du modèle dans la « place de marché des modèles » de la console | | `displayName` / `providerName` | personnalisé, par ex. `aicentos` | Remarque : à l'inverse de la plupart des clients, le profile de Junie exige que `baseUrl` contienne le **point de terminaison complet**, qui doit se terminer par `/chat/completions` ; Junie ne complète pas le chemin lui-même. ## Étapes de configuration * Créez le fichier de profile (le nom du fichier sans `.json` sert d'identifiant de profile) : * Niveau utilisateur : `~/.junie/models/aicentos.json` (`$JUNIE_HOME` vaut par défaut `~/.junie`) * Niveau projet : `/.junie/models/aicentos.json` (le projet doit être marqué comme approuvé) * Écrivez le contenu suivant : ```json { "id": "gpt-5", "baseUrl": "https://aicentos.com/v1/chat/completions", "apiType": "OpenAICompletion", "apiKey": "${AICENTOS_API_KEY}", "displayName": "aicentos GPT", "providerName": "aicentos", "fasterModel": { "id": "gpt-5-mini" } } ``` * Exportez la variable d'environnement : ```bash export AICENTOS_API_KEY="sk-votre-clé-aicentos" ``` * Précisez le profile au lancement, ou sélectionnez-le dans l'interface interactive avec `/model` : ```bash junie --model custom:aicentos ``` ## Test Après le démarrage, faites d'abord un test léger avec une invite simple ; une fois les résultats confirmés, utilisez normalement les workflows agentic. ## Remarques * **Le plugin JetBrains IDE ne prend pas en charge les points de terminaison personnalisés** ; ce profile ne fonctionne que dans Junie CLI. * `baseUrl` doit être le point de terminaison complet (avec `/v1/chat/completions`), à la différence de nombreux clients qui ne demandent que la Base URL. * Les `${VAR}` de `apiKey` et `extraHeaders` sont résolus au chargement du profile ; une variable d'environnement non définie fait échouer le chargement du profile. * Les profiles de niveau projet sont soumis à l'approbation du projet ; un projet non approuvé renvoie `Unknown custom model profile`. * Les petits modèles peinent sur les appels d'outils multi-étapes et les longs contextes de Junie ; choisissez de préférence un modèle capable. * Pour plus de précisions, consultez le site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) --- # Kilo CLI Source: https://docs.aicentos.com/fr/clients/kilo-cli Language: fr > Connecter aicentos à l'outil en ligne de commande Kilo via un fichier de configuration Kilo CLI déclare les providers et les modèles dans un fichier de configuration JSON / JSONC ; il accepte `@ai-sdk/openai-compatible` pour pointer vers n'importe quel point d'accès compatible OpenAI, ce qui permet de se connecter directement à aicentos. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour la CLI (nommez-la par exemple `kilo-cli`). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) Vérifiez également que Kilo CLI est installé globalement : ```bash npm install -g @kilocode/cli ``` ## Configuration à renseigner | Champ | Valeur | | ------------------------------------ | -------------------------------------------------------- | | Paquet du provider (`npm`) | `@ai-sdk/openai-compatible` | | `options.baseURL` | `https://aicentos.com/v1` | | `options.apiKey` | clé créée dans la console (référençable via `{env:VAR}`) | | Référence du modèle (`model` racine) | sous la forme `provider/model`, par ex. `aicentos/gpt-5` | | `limit.context` / `limit.output` | selon le modèle choisi | ## Étapes de configuration * Créez ou éditez le fichier de configuration global : * `~/.config/kilo/kilo.json` (ou `kilo.jsonc`) ; si `XDG_CONFIG_HOME` est défini, c'est ce répertoire qui fait foi. * Un `./kilo.jsonc` au niveau du projet remplace les entrées homonymes de la configuration globale. * Écrivez le contenu suivant : ```json { "$schema": "https://app.kilo.ai/config.json", "model": "aicentos/gpt-5", "provider": { "aicentos": { "npm": "@ai-sdk/openai-compatible", "name": "aicentos", "options": { "baseURL": "https://aicentos.com/v1", "apiKey": "{env:AICENTOS_API_KEY}" }, "models": { "gpt-5": { "name": "GPT-5", "limit": { "context": 128000, "output": 16384 } } } } } } ``` * Exportez la variable d'environnement : ```bash export AICENTOS_API_KEY="sk-votre-clé-aicentos" ``` * Lancez `kilo` dans le répertoire du projet, ou changez de modèle avec `/model` dans l'interface interactive. ## Test Après le démarrage, faites d'abord un test léger avec une invite simple, et ne passez à l'usage réel qu'une fois les retours confirmés. ## Remarques * `options.baseURL` s'arrête à `https://aicentos.com/v1`, ne le complétez pas en chemin complet `/v1/chat/completions`. * La syntaxe de substitution `{env:VAR}` **ne fonctionne que dans le fichier de configuration global** ; par sécurité, un `kilo.jsonc` de projet n'interprète pas `{env:...}`. * Les modèles personnalisés doivent déclarer explicitement `limit.context` et `limit.output`, sinon la longueur de contexte est traitée comme 0 et la compression automatique cesse de fonctionner. * Si la passerelle n'expose pas l'interface de liste `/v1/models`, la détection automatique des modèles échoue ; déclarez-les à la main comme indiqué ci-dessus. * Pour plus de détails, consultez le site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) --- # Kilo Code Source: https://docs.aicentos.com/fr/clients/kilo-code Language: fr > Ajouter un Custom Provider dans l’extension Kilo Code avec la Base URL et la clé API aicentos Kilo Code prend en charge nativement le provider OpenAI Compatible, qui se connecte directement à ce service. ## Installation Page d'installation officielle : [https://marketplace.visualstudio.com/items?itemName=kilocode.kilo-code](https://marketplace.visualstudio.com/items?itemName=kilocode.kilo-code) Avec VS Code, la façon la plus directe d'installer est : ```bash code --install-extension kilocode.kilo-code ``` Avec Windsurf, VSCodium ou un environnement compatible Open VSX, installez la version correspondante depuis le marché d'extensions, selon la documentation officielle de Kilo. ## Ouvrir les réglages Dans le panneau Kilo Code, cliquez sur le bouton de réglages pour accéder à la configuration du provider. ## Configuration à renseigner Réglez l'API Provider sur OpenAI Compatible, puis renseignez : * Base URL : [https://aicentos.com/v1](https://aicentos.com/v1) * API Key : votre clé codex\_... ou sk-..., etc. * Model ID : gpt-5-codex-mini Si le modèle n'apparaît pas automatiquement dans la liste, vous pouvez aussi le saisir manuellement. ## Test Après enregistrement, lancez directement une nouvelle tâche et vérifiez que Kilo Code se connecte normalement et renvoie du contenu. ## Remarques * La documentation officielle de Kilo Code utilise la configuration via le provider OpenAI Compatible * Kilo Code accepte en plus un URL d'endpoint complet, mais ce n'est pas nécessaire pour ce service * Ici, utilisez directement la Base URL, sans la compléter en chemin complet /chat/completions * Documentation officielle de référence : [https://kilo.ai/docs/ai-providers/openai-compatible](https://kilo.ai/docs/ai-providers/openai-compatible) --- # Kilo Source: https://docs.aicentos.com/fr/clients/kilo Language: fr > Connecter aicentos à Kilo via un Provider personnalisé compatible OpenAI Kilo prend en charge les providers personnalisés et permet de diriger les requêtes de conversation et d'Agent vers n'importe quel point de terminaison compatible OpenAI. Il suffit d'ajouter un Custom Provider dans les réglages et d'y renseigner la Base URL et la clé d'aicentos. ## Prérequis Créez d'abord, sur la page « API Key » de la console, une clé dédiée pour Kilo (nommez-la par exemple `kilo`). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) ## Configuration à renseigner | Champ | Valeur | | ----------------- | ------------------------------------------------------------------- | | Provider ID / nom | personnalisé, par ex. `aicentos` | | Type d'API | OpenAI Compatible (Chat Completions) | | Base URL | `https://aicentos.com/v1` | | API Key | clé créée dans la console | | Model ID | nom du modèle dans la « place de marché des modèles » de la console | | Context Window | selon le modèle choisi | | Max Output Tokens | selon le modèle choisi | ## Étapes de configuration * Ouvrez le panneau de réglages de Kilo (icône engrenage). * Rendez-vous dans **Providers**, descendez tout en bas de la liste et choisissez **Custom provider** (provider personnalisé). * Renseignez librement le Provider ID et le Display name, par exemple `aicentos`. * Choisissez **OpenAI Compatible (Chat Completions)** comme type d'API. * Renseignez la Base URL : `https://aicentos.com/v1`. * Saisissez l'API Key créée dans la console. * Ajoutez manuellement le Model ID, avec le nom du modèle de la console. * Après enregistrement, sélectionnez dans le sélecteur de modèles le modèle de ce provider. ## Test Après enregistrement des réglages, créez une nouvelle tâche et faites d'abord un test léger avec une invite simple ; une fois le contenu confirmé, utilisez normalement le mode Agent. ## Remarques * Si la passerelle n'expose pas l'interface de liste `/v1/models`, la détection automatique des modèles échoue ; renseignez simplement le Model ID manuellement. * La Base URL s'arrête à `https://aicentos.com/v1`, ne la complétez pas en chemin complet `/v1/chat/completions`. * Pour les modèles personnalisés, réglez explicitement Context Window et Max Output Tokens ; en cas d'absence, la longueur de contexte est traitée comme 0, ce qui désactive la compression automatique et fait croître la conversation sans limite. * Documentation officielle : [https://kilo.ai/docs/ai-providers/openai-compatible](https://kilo.ai/docs/ai-providers/openai-compatible) * Pour plus de précisions, consultez le site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) --- # Kimchi Source: https://docs.aicentos.com/fr/clients/kimchi Language: fr > Connecter aicentos à Kimchi — changer l'adresse d'inférence via llmEndpoint, avec les limites de cette approche Kimchi est un agent de codage en terminal, qui propose aussi une extension VS Code et le client de bureau Studio. Sa configuration contient un champ `llmEndpoint`, qui pointe par défaut vers `https://llm.kimchi.dev` ; le modifier permet d'envoyer les requêtes d'inférence ailleurs. À préciser d'emblée : **la documentation officielle ne décrit `llmEndpoint` que comme une adresse d'inférence et ne garantit pas qu'elle puisse pointer vers n'importe quelle passerelle tierce compatible OpenAI**. La méthode ci-dessous fonctionne dans la communauté, mais relève d'une « configuration selon la sémantique du champ » : ce n'est pas un chemin BYOK officiellement pris en charge, et elle peut cesser de fonctionner après une mise à niveau. ## Prérequis Créez d'abord dans la console une clé dédiée pour Kimchi (nommez-la par exemple `kimchi`), puis installez le CLI : ```bash brew install getkimchi/tap/kimchi ``` Ou avec le script d'installation : ```bash curl -fsSL https://github.com/getkimchi/kimchi/releases/latest/download/install.sh | bash ``` ## Configuration à renseigner | Champ | Valeur | | ------------- | ------------------------------------------------------------------- | | `llmEndpoint` | `https://aicentos.com/v1` | | `apiKey` | clé créée dans la console | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration Le fichier de configuration se trouve dans `~/.config/kimchi/config.json` ; vous pouvez aussi le surcharger avec un `.kimchi/config.json` au niveau du projet : ```json { "apiKey": "sk-votre-clé-API", "llmEndpoint": "https://aicentos.com/v1" } ``` Les modèles personnalisés se déclarent dans `models.json`, au même format que les providers auto-hébergés du type vLLM ou LM Studio. La spécification des champs n'est pas entièrement publique : mieux vaut d'abord faire fonctionner le modèle par défaut avant d'envisager des entrées personnalisées. Redémarrez `kimchi` après modification. ## Test Après le démarrage, envoyez une invite dans la session. En cas d'erreur 401, vérifiez d'abord que la clé ne contient pas d'espaces superflus ; en cas d'erreur 404, vérifiez que `llmEndpoint` s'arrête bien à `/v1`. Revenez ensuite dans la console consulter la consommation — **c'est l'étape décisive** : si elle n'augmente pas, les requêtes ne passent pas du tout par `llmEndpoint` mais retombent sur l'endpoint par défaut, et cette méthode ne tient donc pas pour la version actuelle. ## Remarques * Kimchi exige la connexion à son propre compte ; `apiKey` et l'état de connexion au compte sont deux choses distinctes, ne faites pas la moitié du travail. * Les modèles externes sont traités par défaut au niveau `standard` avec `vision: false` : un modèle multimodal n'apportera pas d'image ici. * Le modèle par défaut est choisi automatiquement par son propre harness ; vous ne pourrez peut-être pas désigner directement un nom de modèle précis sur aicentos. * La documentation officielle n'a pas décrit cette voie : c'est du « ça marche mais sans garantie ». Prévoyez une solution de repli en production. ## Liens utiles * [Documentation Kimchi CLI](https://docs.kimchi.dev/docs/kimchi-cli) * [Dépôt kimchi](https://github.com/getkimchi/kimchi) --- # Kimi Source: https://docs.aicentos.com/fr/clients/kimi Language: fr > Utiliser aicentos dans Kimi Code CLI : enregistrer un provider compatible OpenAI via config.toml Kimi Code CLI permet d'enregistrer n'importe quel service compatible OpenAI comme provider. Pointez `base_url` vers aicentos et renseignez l'API Key pour appeler directement, dans l'interface du terminal, les modèles intégrés par aicentos. ## Prérequis Créez d'abord, sur la page « API Key » de la console, une clé dédiée pour Kimi Code (nommez-la par exemple `kimi-cli`, pour suivre plus facilement sa consommation). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) * Site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) Le fichier de configuration se trouve par défaut dans `~/.kimi/config.toml` et est créé automatiquement au premier lancement de Kimi Code. ## Configuration à renseigner | Champ | Valeur | | ---------------- | ------------------------------------------------------------------- | | Type de provider | `openai_legacy` (protocole Chat Completions) | | base\_url | `https://aicentos.com/v1` | | api\_key | clé créée dans la console | | model | nom du modèle dans la « place de marché des modèles » de la console | Si le côté aicentos emprunte le protocole Responses, remplacez simplement le type par `openai_responses`. ## Étapes de configuration Ouvrez `~/.kimi/config.toml` et ajoutez un provider personnalisé ainsi qu'un alias de modèle : ```toml default_model = "aicentos-gpt-4o" [providers.aicentos] type = "openai_legacy" base_url = "https://aicentos.com/v1" api_key = "sk-votre-clé" [models.aicentos-gpt-4o] provider = "aicentos" model = "gpt-4o" max_context_size = 128000 ``` * Le nom du provider (`aicentos`) et l'alias du modèle (`aicentos-gpt-4o`) sont tous deux personnalisables ; `default_model` reçoit l'alias, pas l'ID de modèle côté serveur. * Si l'alias contient un `.` (par ex. `gpt-4.1`), il faut le mettre entre guillemets en TOML : `[models."gpt-4.1"]`, sinon le `.` est interprété comme séparateur de tables. * Si vous préférez ne pas écrire le TOML à la main, saisissez `/provider` dans la TUI pour ouvrir le gestionnaire de fournisseurs, validez sur la ligne `[ Add New Platform ]` et suivez l'assistant. Vous pouvez aussi passer uniquement par des variables d'environnement (effectives pour les types `openai_legacy` / `openai_responses`) : ```bash export OPENAI_BASE_URL="https://aicentos.com/v1" export OPENAI_API_KEY="sk-votre-clé" ``` ## Test Lancez `kimi` et envoyez une invite simple dans la TUI ; si la réponse arrive normalement, l'intégration fonctionne. Utilisez `/model` pour vérifier que l'alias sélectionné est bien celui que vous venez de configurer. ## Remarques * Les identifiants du provider sont résolus dans l'ordre : champ `api_key` > sous-table `[providers..env]` > erreur au démarrage ; hormis pour `openai_legacy` / `openai_responses`, les identifiants du fichier de configuration ne sont pas complétés automatiquement depuis les variables d'environnement du shell. * `type = "kimi"` est réservé au point de terminaison officiel de Moonshot ; pour aicentos, utilisez `openai_legacy` ou `openai_responses`. * Ne renseignez pas `max_context_size` en dessous de la fenêtre réelle du modèle ; une valeur trop petite déclenche prématurément la compression de contexte. * La Base URL s'arrête à `/v1`, ne la complétez pas en chemin complet `/v1/chat/completions`. * Le nom du modèle fait foi selon la « place de marché des modèles » de la console (voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list)). --- # Kiro Source: https://docs.aicentos.com/fr/clients/kiro Language: fr > Kiro ne prend pas en charge de Base URL personnalisée : explication de la limite et alternatives possibles **Kiro ne prend actuellement pas en charge de Base URL personnalisée : la connexion directe à aicentos est impossible.** Kiro est l'IDE agentique d'AWS (basé sur Code OSS) ; ses modèles passent tous par son service intégré, adossé à Amazon Bedrock. L'éditeur n'expose aucune entrée de configuration « point d'accès de modèle personnalisé » ni « BYOK (apportez votre propre clé) », et les demandes de fonctionnalités correspondantes de la communauté restent sans suite. ## Prérequis Aucune clé API aicentos à créer pour Kiro — la version actuelle n'offre aucun endroit où la saisir. Informations de référence : * Console : [https://aicentos.com](https://aicentos.com) * Site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) Si vous êtes déjà connecté depuis un autre client, commencez par vérifier que ce client accepte un point d'accès personnalisé. ## Configuration à renseigner | Champ | Valeur | | -------- | --------------------------------------------------------------- | | Base URL | aucun champ de ce type | | Clé API | aucun champ de ce type | | Modèle | à choisir uniquement dans la liste des modèles intégrés de Kiro | ## Étapes de configuration Configuration impossible. Les réglages de Kiro ne proposent que la sélection de modèle (commande `/model` ou sélecteur de modèles) et le champ `model` des agents personnalisés ; or ce champ `model` ne fait que correspondre aux identifiants de modèles renvoyés par le service Kiro et ne peut pas pointer vers un point d'accès externe. ## Alternatives Kiro n'acceptant pas de point d'accès personnalisé, plusieurs voies restent possibles : * **Utiliser un client qui prend en charge nativement une Base URL personnalisée** : Cursor, Windsurf, Cline, Roo Code, Zed Agent, etc., acceptent tous directement `https://aicentos.com/v1`. Voir les autres documents de la section « Connexion des clients ». * **Continuer avec les modèles intégrés de Kiro** : ils sont fournis par AWS, sans lien avec aicentos, et ne peuvent pas être regroupés sur une même facturation. * **Attendre la prise en charge officielle de BYOM / BYOK** : suivez les demandes de fonctionnalités du dépôt officiel de Kiro ; rien n'est encore disponible à ce jour. * **Cas d'une passerelle en réseau d'entreprise** : même avec un proxy LLM interne déployé, Kiro ne peut pas être configuré pour le pointer ; il faudra là aussi attendre la prise en charge officielle. Évitez les contournements non officiels — modification du fichier hosts, certificats auto-signés ou patchs sur l'IDE : ils cassent le mécanisme de mise à jour de Kiro et comportent des risques de sécurité et de conformité. ## Test Aucun point d'accès personnalisé à tester. Pour vérifier la connectivité d'aicentos, utilisez n'importe quel client acceptant une Base URL personnalisée, ou appelez directement : ```bash curl https://aicentos.com/v1/chat/completions \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -d '{"model":"gpt-5","messages":[{"role":"user","content":"hi"}],"stream":false}' ``` ## Remarques * Pour le rappeler : **la version actuelle de Kiro ne prend pas en charge de Base URL personnalisée, la connexion à aicentos est impossible**. * Ce document sera mis à jour au gré des évolutions des capacités officielles de Kiro. * Documentation officielle : [https://kiro.dev/docs](https://kiro.dev/docs) --- # LM Studio Source: https://docs.aicentos.com/fr/clients/lm-studio Language: fr > LM Studio est un serveur d'inférence local, pas un client — son rôle exact et les solutions de remplacement LM Studio est souvent vu comme « encore un client de chat », alors que la logique est inverse : c'est un **exécuteur de modèles locaux**, qui expose une interface compatible OpenAI (par défaut `http://localhost:1234/v1`) pour que d'autres viennent s'y connecter. Il n'offre aucune entrée pour « saisir une Base URL distante » et ne peut donc pas se connecter à aicentos en tant que client. ## Pourquoi une connexion directe est impossible * Sa position officielle est `Serve local models on OpenAI-like endpoints` : un rôle de serveur, pas de consommateur. * Ni le client de bureau ni le CLI `lms` ne proposent de configuration d'endpoint pour un provider tiers. * Ses capacités cloud (LM Studio Secure Cloud, LM Link) sont des canaux de calcul hébergés par l'éditeur et n'acceptent pas d'endpoint tiers personnalisé. ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | API Key | clé créée dans la console | | Base URL | `https://aicentos.com/v1` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | Le tableau ci-dessus regroupe les paramètres génériques côté aicentos, utilisables par les alternatives ci-dessous. ## Alternatives ### Option 1 : inverser l'usage — faire connecter un client à LM Studio Si vous voulez faire tourner des modèles locaux, gardez LM Studio comme serveur et renseignez la Base URL de [Cherry Studio](https://docs.aicentos.com/fr/clients/cherry-studio), [Chatbox](https://docs.aicentos.com/fr/clients/chatbox) et [Cline](https://docs.aicentos.com/fr/clients/cline) sur `http://localhost:1234/v1`. Cette chaîne n'a rien à voir avec aicentos, mais c'est le bon usage de LM Studio. ### Option 2 : pour les modèles aicentos, changez de front-end [Cherry Studio](https://docs.aicentos.com/fr/clients/cherry-studio), [Chatbox](https://docs.aicentos.com/fr/clients/chatbox) et [LobeChat](https://docs.aicentos.com/fr/clients/lobechat) sont des clients de chat de bureau qui prennent en charge la coexistence de plusieurs providers : une entrée pour aicentos, une pour le LM Studio local, et un basculement dans la même interface. ### Option 3 : combiner local et cloud Avec un client comme Cherry Studio, montez les deux providers en parallèle : les tâches simples en local, les tâches complexes sur aicentos, en basculant selon le besoin. ## Test Lorsque LM Studio sert de serveur, lancez d'abord `lms server start`, puis vérifiez que l'interface répond avec `curl http://localhost:1234/v1/models`, et envoyez enfin une invite dans le client. ## Remarques * Ne cherchez pas de champ Base URL dans LM Studio : il n'affiche que l'adresse sur laquelle il écoute. * Le contexte et la vitesse des modèles locaux dépendent de la mémoire GPU de la machine ; pour les tâches à long contexte, préférez aicentos. * Ne confondez pas les deux sens : **le serveur renseigne un port, le client renseigne un endpoint**. ## Liens utiles * [Interface compatible OpenAI de LM Studio](https://lmstudio.ai/docs/api/openai-api) * [CLI lms](https://github.com/lmstudio-ai/lms) --- # LobeChat Source: https://docs.aicentos.com/fr/clients/lobechat Language: fr > Utiliser aicentos dans LobeChat : connexion via des réglages personnalisés compatibles OpenAI LobeChat est une plateforme de chat IA open source qui prend en charge les interfaces compatibles OpenAI et peut se connecter directement à ce service depuis le panneau de réglages. ## Ouvrir les réglages Cliquez sur l'icône **Settings (réglages)** en bas à gauche, puis ouvrez la page **Language Model (modèle de langage)**. ## Choisir le fournisseur OpenAI Dans la liste des fournisseurs, cliquez sur **OpenAI** pour dérouler le panneau de configuration. ## Configuration à renseigner Renseignez les informations suivantes dans le panneau de configuration : * **API Key (apiKey)** : votre clé (`codex_...`, `sk-...`, etc.) * **Adresse du proxy API (baseURL)** : `https://aicentos.com/v1` ## Choisir le modèle et vérifier Choisissez dans le menu déroulant des modèles, ou saisissez manuellement `gpt-5-codex-mini`. Lancez une conversation et vérifiez que la réponse arrive normalement. ## Remarques * L'adresse du proxy API doit contenir le chemin racine du service avec `/v1`, soit `https://aicentos.com/v1` * LobeChat permet de configurer plusieurs fournisseurs en même temps et de basculer selon la conversation * La version auto-hébergée peut être configurée via les variables d'environnement `OPENAI_API_KEY` et `OPENAI_PROXY_URL`, voir la documentation officielle des variables d'environnement ## Liens utiles * Documentation officielle : [https://lobehub.com/docs/usage/providers/openai](https://lobehub.com/docs/usage/providers/openai) --- # MiMo Code Source: https://docs.aicentos.com/fr/clients/mimo-code Language: fr > Utiliser aicentos dans MiMo Code : connexion à un point d'accès compatible OpenAI via la couche de compatibilité MiMo Code accepte dans sa configuration un `base_url` compatible OpenAI. Pointez-le vers aicentos et renseignez la clé API pour que MiMo Code utilise les modèles intégrés par aicentos. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour MiMo Code (nommez-la par exemple `mimo-code`, pour suivre plus facilement sa consommation). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) * Site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) MiMo Code est un outil en CLI ; il s'installe généralement via npm en global. Si le paquet que vous récupérez est une tarball, décompressez-la et placez l'exécutable dans le `PATH`. ```bash npm install -g mimo-code mimo --version ``` ## Configuration à renseigner | Champ | Valeur | | --------- | ------------------------------------------------------------------- | | Clé API | clé créée dans la console | | base\_url | `https://aicentos.com/v1` | | model | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration La méthode recommandée passe par les variables d'environnement, pour une meilleure compatibilité : ```bash export MIMO_BASE_URL="https://aicentos.com/v1" export MIMO_API_KEY="sk-votre-clé" export AICENTOS_API_KEY="$MIMO_API_KEY" export MIMO_MODEL="gpt-4o" ``` Pour un effet permanent, écrivez-les dans `~/.zshrc` ou `~/.bashrc`, puis exécutez `source ~/.zshrc`. Si vous préférez un fichier de configuration, éditez `~/.mimo/config.json` : ```json { "baseUrl": "https://aicentos.com/v1", "apiKey": "sk-votre-clé", "model": "gpt-4o" } ``` Attention : selon les versions, le nommage des options de configuration (`base_url` / `baseUrl`) et le préfixe des variables d'environnement (`MIMO_` / `MIMOCODE_`) peuvent différer. Si les noms de variables ci-dessus ne sont pas pris en compte, vérifiez avec `mimo --help` ou la documentation officielle les noms réellement lus par votre version, plutôt que d'essayer au hasard. ## Test Une fois configuré, lancez directement `mimo` et envoyez une invite simple. En cas d'erreur d'authentification, vérifiez d'abord que le nom des variables d'environnement est bien reconnu par votre version, que `base_url` s'arrête bien à `/v1`, et que la clé ne contient pas d'espace superflu. ## Remarques * Certaines versions comparent le `base_url` au point d'accès officiel intégré au démarrage ; si la configuration semble ignorée, passer par les variables d'environnement permet généralement de contourner le contrôle. * La Base URL s'arrête à `/v1`. * Il est conseillé de vérifier d'abord la visibilité des modèles avec `curl https://aicentos.com/v1/models -H "Authorization: Bearer $AICENTOS_API_KEY"` avant de renseigner le nom du modèle. * Quand variables d'environnement et fichier de configuration coexistent, la priorité varie selon les versions ; ne conservez qu'un seul mode de configuration. --- # MiniMax Code Source: https://docs.aicentos.com/fr/clients/minimax-code Language: fr > Connecter aicentos à MiniMax Code (mcode) — ajouter un provider compatible OpenAI avec provider add MiniMax Code est le CLI de codage officiel de MiniMax (commande `mcode`), avec TUI, exécution headless, ACP et SDK TypeScript intégrés. Il prend en charge le BYOK : `mcode provider add` permet de brancher n'importe quel endpoint compatible OpenAI. ## Prérequis Créez d'abord dans la console une clé dédiée pour MiniMax Code (nommez-la par exemple `minimax-code`), puis installez : ```bash curl -fsSL https://filecdn.minimax.chat/public/install.sh | bash ``` Vous pouvez aussi passer par npm : ```bash npm install -g @minimax-ai/code@latest mcode --version ``` ## Configuration à renseigner | Champ | Valeur | | --------------- | ------------------------------------------------------------------- | | Nom du provider | au choix, par exemple `aicentos` | | `--base-url` | `https://aicentos.com/v1` | | `--api-format` | `openai-completions` | | `--model` | nom du modèle dans la « place de marché des modèles » de la console | | `--api-key-env` | `MCODE_PROVIDER_API_KEY` | ## Étapes de configuration Une seule commande pour l'enregistrer et basculer dessus : ```bash export MCODE_PROVIDER_API_KEY="sk-votre-clé-API" mcode provider add \ --name aicentos \ --base-url https://aicentos.com/v1 \ --api-format openai-completions \ --model votre-nom-de-modèle \ --api-key-env MCODE_PROVIDER_API_KEY \ --use ``` `--use` signifie basculer immédiatement sur ce provider après l'enregistrement. Il écrit la configuration dans la section `custom_provider` du `config.yaml` du profil courant (répertoire de données par défaut `~/.minimax`), soit de façon équivalente : ```yaml custom_provider: aicentos: options: apiKey: sk-votre-clé-API baseURL: https://aicentos.com/v1 models: votre-nom-de-modèle: {} ``` Notez que la clé ici est `baseURL` (URL en majuscules), et non `base-url`. ## Test ```bash mcode exec "Présente-toi en une phrase" ``` Si le mode headless renvoie une réponse, la configuration est effective. Lancez ensuite une vraie tâche dans la TUI, puis vérifiez la consommation dans la console. ## Remarques * Pour un modèle personnalisé, indiquez explicitement les limites de contexte et de sortie (`--context-limit`, `--output-limit`), sinon il applique les valeurs par défaut et les fichiers longs sont facilement tronqués. * Le script d'installation en une commande ne prend pas en charge Alpine / musl ; dans ces environnements, passez par npm. * Si vous voulez passer par le protocole compatible Anthropic comme relais, la requête contient toujours `x-api-key` ; si l'amont n'accepte que `Authorization`, il faut ajouter vous-même une couche de conversion. * Les providers sont stockés **par profil** : après avoir changé de profil, vérifiez à nouveau lequel est actif. ## Liens utiles * [Démarrage rapide de MiniMax Code](https://agent.minimax.io/docs/cli/quick-start) * [Dépôt minimax-code](https://github.com/MiniMax-AI/minimax-code) --- # Mux Source: https://docs.aicentos.com/fr/clients/mux Language: fr > Utiliser aicentos dans Mux : ajout d'un provider personnalisé compatible OpenAI Mux accepte l'ajout de providers personnalisés compatibles OpenAI. Pointez la Base URL vers aicentos et les modèles intégrés par aicentos deviennent utilisables dans les sessions de Mux. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour Mux (nommez-la par exemple `mux`, pour suivre plus facilement sa consommation). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) * Site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) ## Configuration à renseigner | Champ | Valeur | | ---------------- | ------------------------------------------------------------------- | | Type de provider | OpenAI Compatible | | Base URL | `https://aicentos.com/v1` | | Clé API | clé créée dans la console | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration * Ouvrez les réglages de Mux, section Providers / Models. * Choisissez d'ajouter un provider personnalisé, avec le type **OpenAI Compatible**. * Renseignez la clé API. * Renseignez la Base URL : `https://aicentos.com/v1` * Renseignez le modèle avec un nom issu de la « place de marché des modèles » de la console (voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list)). * Enregistrez, puis définissez ce provider comme celui de la session en cours. ## Test Créez une nouvelle session et envoyez une invite simple ; une réponse normale signifie que la connexion fonctionne. Si le modèle saisi n'apparaît pas automatiquement dans la liste, entrez manuellement l'ID du modèle et réessayez. ## Remarques * La Base URL s'arrête à `/v1`, ne la complétez pas en chemin complet `/v1/chat/completions`. * Le nom des réglages peut varier légèrement selon les versions, mais la configuration compatible OpenAI s'articule toujours autour des trois champs Base URL, clé API et modèle. * Une Base URL erronée, une clé contenant un espace superflu ou un solde insuffisant se traduisent généralement par des erreurs 401 / 403 / 402 ; vérifiez-les une à une. * Si votre version de Mux ne propose que quelques éditeurs prédéfinis et ne permet pas de personnaliser la Base URL, elle ne prend pas en charge les points d'accès tiers ; passez alors à un autre client acceptant une Base URL personnalisée. --- # NativeTavern Source: https://docs.aicentos.com/fr/clients/nativetavern Language: fr > Connecter NativeTavern à l’API compatible OpenAI d’aicentos avec la Base URL et votre clé API # NativeTavern NativeTavern est la version mobile native de SillyTavern, disponible sur iOS et Android, qui permet de se connecter à une API personnalisée via une interface compatible OpenAI. ## Installer l'application Téléchargez et installez NativeTavern depuis la boutique d'applications de votre plateforme : * iOS : App Store * Android : Google Play ## Configurer la connexion API 1. Ouvrez l'application NativeTavern 2. Accédez à **Réglages** ou **Settings** 3. Choisissez **API Configuration** 4. Sélectionnez comme type d'API **OpenAI** ou **OpenAI Compatible** ## Configuration à renseigner Dans la page de configuration, renseignez : * **API URL** : `https://aicentos.com/v1` * **API Key** : votre clé API (par ex. `codex_...` ou `sk-...`) * **Model** : choisissez ou saisissez l'ID du modèle (par ex. `gpt-6-astra`) ## Tester la connexion 1. Après avoir enregistré les réglages, revenez à l'écran principal 2. Créez ou sélectionnez un personnage 3. Envoyez un message pour vérifier que la connexion fonctionne ## Remarques * L'application mobile peut nécessiter une connexion réseau stable * L'API URL se renseigne jusqu'à `/v1`, sans le chemin complet * La plupart des fonctionnalités de SillyTavern sont prises en charge ## Liens utiles NativeTavern fait partie de l'écosystème SillyTavern ; pour plus d'informations, consultez la communauté SillyTavern. --- # NextChat Source: https://docs.aicentos.com/fr/clients/nextchat Language: fr > Utiliser aicentos dans NextChat : connexion via des réglages personnalisés compatibles OpenAI NextChat est un client web ChatGPT open source très répandu, qui prend en charge une interface personnalisée compatible OpenAI. ## Configuration via l'interface - ouvrir les réglages Cliquez sur l'icône **Settings (réglages)** en bas à gauche ## Configuration via l'interface - activer l'interface personnalisée Dans le panneau de réglages, trouvez l'interrupteur **Custom Endpoint (interface personnalisée)** et activez-le pour faire apparaître les champs de saisie ## Configuration via l'interface - renseigner les informations de connexion Renseignez les informations suivantes : | Champ | Valeur à renseigner | | ---------------- | --------------------------------------- | | OpenAI API Key | votre clé (`codex_...`, `sk-...`, etc.) | | URL du proxy API | `https://aicentos.com/v1` | ## Configuration via l'interface - vérification Après enregistrement, lancez une conversation pour vérifier que la réponse arrive normalement ## Configuration d'un déploiement auto-hébergé Pour une instance auto-hébergée, configurez via les variables d'environnement : ```bash OPENAI_API_KEY=codex_your_api_key BASE_URL=https://aicentos.com/v1 ``` Redémarrez le service après la configuration pour que cela prenne effet. ## Modèles personnalisés Dans le menu déroulant **Model (modèle)** du panneau de réglages, vous pouvez saisir manuellement `gpt-5-codex-mini` ou tout autre nom de modèle disponible. La version auto-hébergée peut aussi préconfigurer la liste des modèles via la variable d'environnement `CUSTOM_MODELS`, par exemple : ```bash CUSTOM_MODELS=gpt-5-codex-mini ``` ## Remarques * Renseignez l'URL du proxy API avec le chemin racine du service incluant `/v1`, soit `https://aicentos.com/v1` * Les modèles disponibles sont ceux renvoyés par `GET /v1/models` ## Liens utiles * GitHub : [https://github.com/ChatGPTNextWeb/NextChat](https://github.com/ChatGPTNextWeb/NextChat) --- # Oh My Pi Source: https://docs.aicentos.com/fr/clients/oh-my-pi Language: fr > Connecter aicentos à Oh My Pi (omp) — ajouter un provider openai-completions dans models.yml Oh My Pi est un fork de Pi, dont le cœur a été réécrit en Rust, avec la commande `omp`. Il définit ses providers dans `~/.omp/agent/models.yml` : il suffit de renseigner clairement les champs `baseUrl` / `api` / `apiKey` pour pointer vers aicentos. ## Prérequis Créez d'abord dans la console une clé dédiée pour Oh My Pi (nommez-la par exemple `oh-my-pi`). L'exécution nécessite bun 1.4.4 ou supérieur : ```bash curl -fsSL https://omp.sh/install | sh ``` Une distribution via Homebrew ou npm est également disponible : ```bash brew install can1357/tap/omp # ou bun install -g @oh-my-pi/pi-coding-agent ``` ## Configuration à renseigner | Champ | Valeur | | --------------- | ------------------------------------------------------------------- | | Nom du provider | au choix, par exemple `aicentos` | | `baseUrl` | `https://aicentos.com/v1` | | `api` | `openai-completions` | | `apiKey` | clé créée dans la console | | `models[].id` | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration Modifiez `~/.omp/agent/models.yml` : ```yaml providers: aicentos: baseUrl: https://aicentos.com/v1 api: openai-completions apiKey: sk-votre-clé-API models: - id: votre-nom-de-modèle contextWindow: 128000 ``` Définissez-le comme modèle par défaut dans `~/.omp/agent/config.yml` : ```yaml modelRoles: default: aicentos/votre-nom-de-modèle ``` Si vous ne voulez pas écrire la clé dans le fichier, remplacez `apiKey` par une référence à une variable d'environnement, et faites `export AICENTOS_API_KEY="sk-votre-clé-API"` avant le lancement. ## Test ```bash omp models aicentos ``` Si les modèles que vous venez de configurer sont listés, le provider est bien reconnu. Lancez ensuite la TUI, envoyez une phrase pour confirmer que la réponse arrive, puis vérifiez la consommation dans la console. ## Remarques * `api` doit être `openai-completions` (ou un autre nom de protocole qu'il reconnaît) ; `openai` sera traité comme un protocole inconnu. * Il désactive par défaut un grand nombre d'outils : si la connexion réussit mais que « rien ne fonctionne », regardez d'abord les interrupteurs d'outils, ce n'est pas un problème d'endpoint. * Ouvrir un dépôt charge la configuration et les hooks au niveau du projet : assurez-vous que le dépôt est fiable avant de vous connecter. * Sur Alpine, installez en plus `libstdc++` et `libgcc`. ## Liens utiles * [Documentation des providers d'Oh My Pi](https://omp.sh/docs/providers) * [Dépôt oh-my-pi](https://github.com/can1357/oh-my-pi) --- # OpenClaw Source: https://docs.aicentos.com/fr/clients/openclaw Language: fr > Utiliser aicentos dans OpenClaw : connexion via un provider personnalisé OpenClaw est un assistant de programmation en ligne de commande qui prend en charge la connexion à des services API compatibles OpenAI via un provider personnalisé. La méthode officiellement recommandée consiste à passer par l'assistant `openclaw onboard`, mais vous pouvez aussi écrire le fichier de configuration à la main. ## Prérequis Assurez-vous que le système remplit les conditions suivantes : * Node.js 22 ou supérieur * macOS / Linux / Windows * Une installation supplémentaire de pnpm si vous compilez depuis les sources ### Installation de Node.js **macOS (avec Homebrew) :** ```bash brew install node ``` **Autres systèmes :** Téléchargez la version LTS depuis le site officiel de Node.js : [https://nodejs.org/en/download](https://nodejs.org/en/download) ### Vérification de l'installation ```bash node -v npm -v ``` **Remarque :** sous Windows, il est conseillé d'exécuter OpenClaw dans un environnement WSL2. ## Installation d'OpenClaw Utilisez le script d'installation officiel (recommandé) : ### macOS / Linux ```bash curl -fsSL https://openclaw.ai/install.sh | bash ``` ### Windows PowerShell ```powershell iwr -useb https://openclaw.ai/install.ps1 | iex ``` Le script d'installation détecte et complète automatiquement les dépendances manquantes. Si vous gérez déjà vous-même votre environnement Node, vous pouvez aussi installer via `npm` ou `pnpm` (voir la documentation officielle). ## Lancement de l'assistant de configuration Exécutez la commande de l'assistant : ```bash openclaw onboard ``` Renseignez ensuite, dans l'assistant, les informations suivantes : * **Type de provider** : choisissez `Custom Provider` * **Compatibility** : choisissez `OpenAI-compatible` * **Base URL** : `https://aicentos.com/v1` * **API Key** : renseignez votre clé API * **Model ID** : reportez-vous aux noms de modèles de la « place de marché des modèles » de la console * **Endpoint ID** : il est conseillé de saisir `aicentos` **Remarque :** la clé API peut être saisie directement en clair ; inutile de la remplacer par la variable d'environnement `OPENAI_API_KEY`. ## Définition du modèle par défaut Une fois l'assistant terminé, définissez le modèle par défaut sur : ```text aicentos/gpt-4o ``` Les utilisations suivantes reprendront automatiquement le modèle configuré. ## Configuration manuelle (facultatif) Si vous n'utilisez pas l'assistant, vous pouvez écrire directement le fichier de configuration des providers d'OpenClaw : ```json { "models": { "providers": { "aicentos": { "baseUrl": "https://aicentos.com/v1", "apiKey": "your_api_key_here", "api": "openai-completions", "models": [ { "id": "gpt-4o", "name": "gpt-4o" } ] } } }, "agents": { "defaults": { "model": { "primary": "aicentos/gpt-4o" } } } } ``` La clé API peut être écrite en clair dans la configuration, ou référencée via une variable d'environnement (si vous préférez l'approche SecretRef). ## Vérification de la configuration Contrôlez l'état des modèles pour confirmer que la connexion fonctionne : ```bash openclaw models list openclaw models status ``` Si vous voyez `aicentos/gpt-4o` avec un état normal, la configuration est opérationnelle. ## Remarques * OpenClaw prend en charge officiellement les providers personnalisés, avec un mode OpenAI-compatible ou Anthropic-compatible au choix * Pour ce service, privilégiez le mode OpenAI-compatible * Saisir directement la clé API est l'approche par défaut ; la référence par variable d'environnement n'est qu'une option * Si vous souhaitez qu'un outil écrive la configuration pour vous, vous pouvez envisager l'outil `cc-switch` * La documentation officielle décrit d'autres méthodes d'installation et de configuration, à choisir selon vos besoins ## Liens utiles * Documentation officielle : [https://docs.openclaw.ai/install/index](https://docs.openclaw.ai/install/index) --- # OpenCode Source: https://docs.aicentos.com/fr/clients/opencode Language: fr > Utiliser aicentos dans OpenCode : connexion d'un provider personnalisé via le fichier de configuration OpenCode prend en charge les providers personnalisés et permet de connecter le service Codex Proxy via un fichier de configuration. ## Prérequis Le site d'OpenCode propose un script d'installation officiel, ainsi que des installations via npm, bun, brew, etc. * Si vous utilisez directement le script d'installation officiel, configurer npm au préalable est en principe inutile * Si vous passez par npm, installez d'abord Node.js et npm * Si vous passez par bun, installez d'abord bun ### Installation de Node.js (méthode npm) La page officielle de téléchargement de Node.js : [https://nodejs.org/en/download](https://nodejs.org/en/download) * macOS / Windows : téléchargez et installez la version LTS * Linux : installez selon la méthode propre à votre distribution, indiquée sur cette page Sous macOS avec Homebrew déjà installé, vous pouvez aussi exécuter directement : ```bash brew install node ``` Cela installe Node.js et npm en même temps. Vérifiez que les commandes correspondant à votre méthode d'installation sont disponibles. Pour la méthode npm, contrôlez par exemple : ```bash node -v npm -v ``` **Remarque :** si vous utilisez un environnement en ligne de commande sous Windows, l'éditeur recommande pour l'instant de passer par WSL. ## Installation Utilisez de préférence la commande d'installation fournie sur le site d'OpenCode : ```bash curl -fsSL https://opencode.ai/install | bash ``` Le site d'OpenCode propose également des installations via npm, bun, brew, etc. ## Définition de la clé API Passez par le mécanisme de connexion ou d'authentification propre à OpenCode : ```bash opencode auth login ``` Ou exécutez /connect dans l'interface interactive pour enregistrer ce service comme provider personnalisé. Si vous préférez les variables d'environnement, faites lire à opencode.json le nom de variable officiel standard, par exemple : ```bash export OPENAI_API_KEY="your_api_key_here" ``` ## Configuration de opencode.json Créez un fichier opencode.json à la racine du projet ou dans le répertoire de configuration global : ```json { "$schema": "https://opencode.ai/config.json", "provider": { "aicentos": { "npm": "@ai-sdk/openai", "name": "aicentos", "options": { "baseURL": "https://aicentos.com/v1", "apiKey": "{env:OPENAI_API_KEY}" }, "models": { "gpt-4o": { "name": "gpt-4o" } } } }, "model": "aicentos/gpt-4o" } ``` ## Test Après le démarrage d'OpenCode, exécutez : ``` /models ``` Les modèles sous aicentos doivent apparaître. ## Remarques * Ordre recommandé : d'abord le fichier de configuration à la main (opencode.json), puis les variables d'environnement, et seulement en dernier l'outil cc-switch ([https://github.com/farion1231/cc-switch/releases](https://github.com/farion1231/cc-switch/releases)) * Si vous utilisez /v1/responses, la documentation officielle d'OpenCode recommande @ai-sdk/openai * Ne passez à @ai-sdk/openai-compatible que si votre connexion ne prend en charge que /v1/chat/completions * Inutile de définir des variables propres au projet comme CODEX\_PROXY\_API\_KEY ## Liens utiles * Site officiel : [https://opencode.ai/](https://opencode.ai/) --- # OpenCodeReview Source: https://docs.aicentos.com/fr/clients/opencodereview Language: fr > Utiliser aicentos dans OpenCodeReview (OCR) : revue de code via un provider personnalisé OpenCodeReview (commande `ocr`) est la CLI de revue de code IA open source d'Alibaba : après lecture du diff Git, elle appelle un grand modèle pour produire des commentaires de revue. Elle intègre un provider compatible OpenAI et prend aussi en charge les passerelles personnalisées compatibles OpenAI, ce qui permet de rediriger les requêtes vers aicentos. ## Prérequis Créez une clé dédiée dans la console aicentos (nommez-la par exemple `ocr-ci`, pour suivre plus facilement sa consommation). OCR ne prend en charge que les protocoles OpenAI / Anthropic ; ici, on emprunte le chemin Chat Completions d'OpenAI. La revue de code dépend de la capacité **function calling** du modèle ; choisissez un modèle prenant en charge l'appel d'outils. ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------------------------------ | | provider | `openai` (intégré, dont on remplace l'URL) ou provider personnalisé | | protocol | `openai` (Chat Completions) | | URL | `https://aicentos.com/v1` | | API Key | clé créée dans la console | | Modèle | nom du modèle dans la « place de marché des modèles » de la console, avec function calling | ## Étapes de configuration * Installez la CLI (Node.js requis, ou Homebrew sur macOS) : ```bash npm install -g open-code-review ``` * Écrivez la configuration avec les commandes non interactives, qui aboutissent dans `~/.opencodereview/config.json` : ```bash ocr config set provider openai ocr config set model claude-sonnet-5 ocr config set providers.openai.url https://aicentos.com/v1 ocr config set providers.openai.api_key your_api_key_here ``` * Si vous préférez un assistant graphique, lancez directement `ocr config provider` et `ocr config model` : dans la TUI, choisissez le provider, saisissez la clé, sélectionnez le modèle ; à la fin, un test de connectivité est exécuté automatiquement. ## Test Vérifiez d'abord le point de terminaison isolément : ```bash ocr llm test ``` Une fois validé, exécutez une revue réelle dans n'importe quel dépôt Git : ```bash ocr review ``` ## Remarques * L'URL s'arrête à `/v1`, ne la complétez pas en chemin complet `/chat/completions`. * Le resolver de configuration exige le trio complet **URL, clé, modèle** ; un simple `export` de variables d'environnement ne suffit pas, les éléments manquants doivent être écrits dans config.json, sinon la réponse est 401. * Vous pouvez aussi remplacer temporairement la configuration par des variables d'environnement, qui ont la priorité la plus haute : `OCR_LLM_URL` / `OCR_LLM_TOKEN` / `OCR_LLM_MODEL`. * Les champs du provider intégré sont `providers..url`, ceux du provider personnalisé `custom_providers..url` ; ne mélangez pas les deux map. * En cas de solde insuffisant, le symptôme est 401 / 403 ; vérifiez d'abord le solde sur la [page du portefeuille](https://aicentos.com/wallet). * Dépôt officiel : `https://github.com/alibaba/open-code-review` --- # Orca Source: https://docs.aicentos.com/fr/clients/orca Language: fr > Utiliser aicentos dans Orca : ajouter un point de terminaison personnalisé compatible OpenAI Orca permet de configurer un service personnalisé compatible OpenAI. Pointez la Base URL vers aicentos et renseignez l'API Key pour utiliser, dans Orca, les modèles intégrés par aicentos. ## Prérequis Créez d'abord, sur la page « API Key » de la console, une clé dédiée pour Orca (nommez-la par exemple `orca`, pour suivre plus facilement sa consommation). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) * Site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) ## Configuration à renseigner | Champ | Valeur | | ---------------- | ------------------------------------------------------------------- | | Type de provider | OpenAI Compatible | | Base URL | `https://aicentos.com/v1` | | API Key | clé créée dans la console | | Model | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration * Ouvrez la page de réglages d'Orca et rendez-vous dans la zone de configuration des modèles / du provider. * Ajoutez un provider, avec le type OpenAI compatible (OpenAI Compatible / Custom OpenAI). * Base URL : `https://aicentos.com/v1` * API Key : la clé créée dans la console. * Model : le nom du modèle dans la « place de marché des modèles » de la console (voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list)). * Enregistrez et définissez-le comme modèle par défaut. ## Test Créez une nouvelle conversation et envoyez une invite simple, puis vérifiez que la réponse arrive normalement. Si le menu déroulant des modèles est vide, saisissez plutôt le Model ID manuellement. ## Remarques * La Base URL s'arrête à `/v1`, ne la complétez pas en chemin complet `/v1/chat/completions`. * Si les réglages ne prennent pas effet immédiatement après enregistrement, redémarrez Orca. * Si votre version d'Orca n'accepte que les providers officiels intégrés, sans entrée de Base URL personnalisée, elle ne peut pas se connecter à un point de terminaison tiers ; passez à un autre client prenant en charge une Base URL personnalisée. * Causes fréquentes d'échec de connexion : Base URL mal saisie, espaces en début ou fin de clé, modèle inexistant, solde du compte insuffisant. --- # Paseo Source: https://docs.aicentos.com/fr/clients/paseo Language: fr > Connecter aicentos à Paseo — il ne joint pas les modèles directement, la configuration se fait dans le CLI sous-jacent ou via provider env Paseo est une couche d'orchestration : client de bureau, mobile, Web et CLI `paseo`, mais **il n'embarque pas d'agent** : il se charge d'exécuter les CLI de codage que vous avez installés et connectés (Claude Code, Codex, OpenCode, Pi, etc.). « Connecter aicentos dans Paseo » revient donc à faire passer par aicentos le CLI hébergé. ## Prérequis Installez d'abord Paseo, et préparez au moins un CLI sous-jacent : ```bash npm install -g @getpaseo/cli paseo ``` Les clients de bureau et mobile se téléchargent depuis le site officiel. À noter : l'image Docker ne contient aucun CLI d'agent, il faut les installer soi-même pour un déploiement en conteneur. ## Configuration à renseigner Les providers de Paseo se définissent dans `agents.providers` du fichier `~/.paseo/config.json`, sous une clé d'identifiant libre, avec les champs `extends`, `label`, `env` et `models`. **Ce qu'il prend en charge, c'est l'injection de variables d'environnement dans le CLI sous-jacent** ; les exemples officiels utilisent tous le protocole compatible Anthropic : | Champ | Valeur | | ------------------------ | ------------------------------------------------------------------- | | `extends` | CLI sous-jacent, par exemple `claude` | | `env.ANTHROPIC_BASE_URL` | `https://aicentos.com` | | `env.ANTHROPIC_API_KEY` | clé créée dans la console | | `models` | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration Modifiez `~/.paseo/config.json` : ```json { "agents": { "providers": { "aicentos-claude": { "extends": "claude", "label": "aicentos", "env": { "ANTHROPIC_BASE_URL": "https://aicentos.com", "ANTHROPIC_API_KEY": "sk-votre-clé-API" } } } } } ``` Rechargez après modification : ```bash paseo reload ``` Sélectionnez ensuite `aicentos` comme provider de la session dans Paseo. Si vous hébergez un CLI au protocole OpenAI (par exemple Codex), remplacez `env` par les variables propres à ce CLI (`OPENAI_BASE_URL`, `OPENAI_API_KEY`) et utilisez `https://aicentos.com/v1` comme Base URL. ## Test ```bash paseo run --provider aicentos-claude "Présente-toi en une phrase" ``` Si une réponse revient, c'est bon. Vous pouvez aussi créer une session directement dans le client de bureau et vérifier que l'étiquette de modèle affiche bien le provider configuré. ## Remarques * **Paseo n'a pas de configuration de modèles en propre.** Il est normal de ne pas trouver de champ Base URL : cherchez dans le CLI sous-jacent ou dans `env`. * La documentation officielle ne donne d'exemples de champs que pour la compatibilité Anthropic ; la syntaxe pour un endpoint compatible OpenAI n'est pas spécifiée. Suivez les noms de variables du CLI sous-jacent et fiez-vous aux tests réels. * `env` écrase l'état de connexion déjà enregistré par le CLI sous-jacent : une erreur de configuration fera aussi échouer des sessions qui fonctionnaient. Mieux vaut créer un nouveau provider plutôt que modifier celui par défaut. * L'authentification du CLI sous-jacent doit être faite au préalable ; Paseo ne se connecte pas à votre place. ## Liens utiles * [Documentation des providers personnalisés de Paseo](https://paseo.sh/docs/custom-providers) * [Dépôt paseo](https://github.com/getpaseo/paseo) --- # Pi Source: https://docs.aicentos.com/fr/clients/pi Language: fr > Utiliser aicentos dans Pi : configurer un point de terminaison personnalisé compatible OpenAI Pi permet de préciser une adresse API personnalisée compatible OpenAI. Pointez la Base URL vers aicentos et renseignez l'API Key pour utiliser, dans Pi, les modèles intégrés par aicentos. ## Prérequis Créez d'abord, sur la page « API Key » de la console, une clé dédiée pour Pi (nommez-la par exemple `pi`, pour suivre plus facilement sa consommation). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) * Site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | Provider | OpenAI Compatible | | Base URL | `https://aicentos.com/v1` | | API Key | clé créée dans la console | | Model | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration * Ouvrez les réglages de Pi et trouvez la zone de configuration API / modèles. * Choisissez un provider personnalisé compatible OpenAI. * Base URL : `https://aicentos.com/v1` * API Key : la clé créée dans la console. * Model : le nom du modèle dans la « place de marché des modèles » de la console (voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list)). * Enregistrez, puis sélectionnez ce modèle dans la session. ## Test Lancez une conversation simple et vérifiez que la réponse arrive normalement. Avec `/model` ou la page de réglages, vérifiez que le modèle courant provient bien d'aicentos et non du provider par défaut intégré. ## Remarques * La Base URL s'arrête à `/v1`, ne l'écrivez pas en chemin d'interface complet. * Si Pi conserve également des providers intégrés, pensez à rebasculer sur celui que vous venez de créer, sinon les requêtes ne passent pas par aicentos. * Si votre version de Pi n'offre pas de Base URL personnalisée, la connexion à un point de terminaison tiers est impossible ; passez à un autre client prenant en charge une Base URL personnalisée. * Il est conseillé de créer une clé dédiée à ce client, pour distinguer facilement la consommation par clé dans la console. --- # Prime Agent Source: https://docs.aicentos.com/fr/clients/prime-agent Language: fr > Connecter aicentos à Prime Agent — seul un provider à clé API est disponible pour l'instant, le champ d'endpoint n'est pas documenté Prime Agent est un agent de codage en terminal open source de Prime Intellect (implémenté en Rust, licence MIT), présenté comme un « harness RLM auto-améliorable ». Il permet de connecter des modèles externes avec une clé API, mais **le champ de Base URL personnalisée n'est pas documenté officiellement** ; la suite est donc séparée en deux parties : « confirmé fonctionnel » et « à vérifier soi-même ». ## Prérequis Créez d'abord dans la console une clé dédiée pour Prime Agent (nommez-la par exemple `prime-agent`). ```bash curl -fsSL https://app.primeintellect.ai/prime-agent/install.sh | sh ``` Windows : ```powershell irm https://app.primeintellect.ai/prime-agent/install.ps1 | iex ``` ## Configuration à renseigner | Champ | Valeur | | -------------------------- | ------------------------------------------------------------------- | | Méthode d'authentification | `/login` au premier lancement, choisir un provider à clé API | | API Key | clé créée dans la console | | Base URL | `https://aicentos.com/v1` (nom du champ à vérifier) | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration Au premier lancement, exécutez `/login` et choisissez un provider à clé API plutôt qu'un abonnement. Ce chemin est explicitement décrit dans la documentation officielle. Son fichier de configuration connu est `models.json`, et la documentation officielle ne publie que la syntaxe de surcharge des modèles : ```json { "providers": { "votre-provider": { "modelOverrides": { "votre-nom-de-modèle": { "contextWindow": 128000 } } } } } ``` `modelOverrides` ne modifie que les paramètres du modèle, **ce n'est pas une définition d'endpoint**. Pour changer d'endpoint, il faut trouver le champ correspondant dans le provider choisi via `/login` — le README du dépôt officiel ne donne pas le nom du champ ; mieux vaut regarder quelles clés figurent dans le fichier de configuration généré au démarrage, puis les renseigner en conséquence, sans deviner. ## Test ```bash prime-agent ``` Envoyez une invite dans la session. Une erreur d'authentification indique un mauvais choix de provider ; si la réponse arrive mais avec un nom de modèle incorrect, c'est que l'endpoint et le modèle se configurent séparément : retournez vérifier `models.json`. ## Remarques * **Ce n'est pas un bac à sable de sécurité** : il exécute le Python et les commandes générés par le modèle avec vos permissions utilisateur. N'y lancez pas de tâches inconnues sur une machine contenant des identifiants de production. * La télémétrie est activée par défaut ; `PRIME_AGENT_TELEMETRY=0` permet de la désactiver. * Sur un réseau d'entreprise nécessitant une CA personnalisée, utilisez `NODE_EXTRA_CA_CERTS`. * Le champ d'endpoint n'est pas public : c'est un état « à explorer soi-même ». Si vous n'y arrivez pas, passez à [Oh My Pi](https://docs.aicentos.com/fr/clients/oh-my-pi) ou [Gajae Code](https://docs.aicentos.com/fr/clients/gajae-code), dont les champs sont explicites. ## Liens utiles * [Dépôt prime-agent](https://github.com/PrimeIntellect-ai/prime-agent) --- # Qwen Source: https://docs.aicentos.com/fr/clients/qwen Language: fr > Utiliser aicentos dans Qwen Code : configurer un provider compatible OpenAI via settings.json Qwen Code permet d'enregistrer n'importe quel point d'accès compatible OpenAI via `modelProviders` dans `settings.json`. Pointez `baseUrl` vers aicentos et les modèles intégrés par aicentos deviennent utilisables dans Qwen Code. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour Qwen Code (nommez-la par exemple `qwen-code`, pour suivre plus facilement sa consommation). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) * Site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) Qwen Code exige Node.js 20 ou supérieur ; installez-le globalement via npm : ```bash npm install -g @qwen-code/qwen-code qwen --version ``` ## Configuration à renseigner | Champ | Valeur | | ------------ | -------------------------------------------------------------------- | | Type d'auth | `openai` (protocole compatible OpenAI) | | baseUrl | `https://aicentos.com/v1` | | envKey | nom de la variable d'environnement stockant la clé (personnalisable) | | id du modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration Éditez `~/.qwen/settings.json` : ```json { "env": { "AICENTOS_API_KEY": "sk-votre-clé" }, "modelProviders": { "openai": [ { "id": "gpt-4o", "name": "GPT-4o", "baseUrl": "https://aicentos.com/v1", "envKey": "AICENTOS_API_KEY" } ] }, "security": { "auth": { "selectedType": "openai" } }, "model": { "name": "gpt-4o" } } ``` * `id` est l'identifiant de modèle réellement envoyé au serveur ; il doit correspondre au nom du modèle dans la console. * Dans `modelProviders`, n'écrivez pas la clé en clair : `envKey` n'est qu'une référence indiquant « dans quelle variable d'environnement aller chercher la clé ». * Priorité de la clé : variables d'environnement système > fichier `.env` (`~/.qwen/.env`) > bloc `env` de `settings.json`. * Si le côté aicentos passe par le protocole Responses, ajoutez `"wireApi": "responses"` sur ce modèle ; sans cela, Chat Completions est utilisé par défaut. Vous pouvez aussi éviter complètement de modifier le fichier de configuration et passer par des variables d'environnement : ```bash export OPENAI_BASE_URL="https://aicentos.com/v1" export OPENAI_API_KEY="sk-votre-clé" export OPENAI_MODEL="gpt-4o" ``` ## Test Lancez `qwen`, vérifiez avec `/about` que le endpoint et le modèle courant sont corrects, puis envoyez un prompt simple. Si plusieurs entrées de provider sont configurées, vous pouvez basculer avec `/model`. ## Remarques * La configuration globale se place dans `~/.qwen/settings.json`, la configuration de projet dans `.qwen/settings.json` à la racine du projet, cette dernière étant prioritaire. * `security.auth.selectedType` doit valoir `openai`, sinon le point d'accès personnalisé n'est pas utilisé. * Ne commitez pas la clé en clair dans un dépôt ; préférez `~/.qwen/.env` ou les variables d'environnement système. * `wireApi` n'est qu'une métadonnée de routage locale, elle n'est pas envoyée dans le corps de la requête ; avant de passer à `responses`, vérifiez que le côté aicentos prend en charge `/v1/responses`. * La Base URL s'arrête à `/v1`, ne la complétez pas en chemin d'interface complet. --- # Reasonix Source: https://docs.aicentos.com/fr/clients/reasonix Language: fr > Utiliser aicentos dans Reasonix : ajout d'un provider personnalisé via config.toml Reasonix est un agent de codage local (CLI/TUI, application de bureau, interface navigateur et ACP pour éditeurs : quatre points d'entrée qui partagent le même moteur). Il n'intègre pas de provider aicentos, mais il accepte dans `~/.reasonix/config.toml` une entrée `[[providers]]` compatible OpenAI qui redirige les requêtes vers aicentos. ## Prérequis Créez une clé dédiée dans la console aicentos (nommez-la par exemple `reasonix-cli`). Les clés des providers de Reasonix sont stockées dans son propre `.env` global ; il ne lit pas les variables d'environnement du shell. ## Configuration à renseigner | Champ | Valeur | | ------------- | ---------------------------------------------------------------------- | | name | `aicentos` (ID local du provider) | | kind | `openai` (Chat Completions) | | base\_url | `https://aicentos.com/v1` | | api\_key\_env | `AICENTOS_API_KEY` | | models | noms des modèles dans la « place de marché des modèles » de la console | ## Étapes de configuration * Installez Reasonix (npm ou Homebrew sur macOS) : ```bash npm i -g reasonix ``` * Écrivez la clé dans le `.env` global de Reasonix : ```bash # macOS / Linux echo 'AICENTOS_API_KEY=your_api_key_here' >> ~/.reasonix/.env # Windows : %APPDATA%\reasonix\.env ``` * Éditez `~/.reasonix/config.toml` en y fusionnant le bloc suivant (ne supprimez pas les autres providers existants) : ```toml default_model = "aicentos" [[providers]] name = "aicentos" kind = "openai" base_url = "https://aicentos.com/v1" models = ["claude-sonnet-5", "deepseek-v4-pro", "qwen3-coder-plus"] default = "claude-sonnet-5" api_key_env = "AICENTOS_API_KEY" context_window = 200000 ``` * Placez-vous dans le répertoire du projet et lancez : ```bash reasonix ``` Vous pouvez aussi valider d'abord avec une tâche ponctuelle : `reasonix run "Explique en une phrase quel projet se trouve dans le répertoire courant"`. Depuis l'application de bureau, passez par **Settings → Model → Access → Add model service → Custom provider**. ## Test Après le démarrage, envoyez une invite simple et vérifiez que la réponse arrive en streaming. Dans la session, `/model` permet de changer de modèle. ## Remarques * `base_url` s'arrête à `/v1` ; Reasonix ajoute lui-même `/chat/completions`. * La clé doit être écrite dans `~/.reasonix/.env` ; un `export` dans le shell ou un `.env` de projet n'est pas reconnu comme clé de provider. * Choisissez `openai` pour `kind` ; le type natif `anthropic` correspond au point d'accès Anthropic Messages et ne convient pas ici. * `default_model` reçoit le `name` du provider (`aicentos`), pas un nom de modèle. * Si le formulaire du provider personnalisé de l'application de bureau exige une adresse complète, saisissez `https://aicentos.com/v1/chat/completions`. * Adresse du projet : `https://github.com/esengine/DeepSeek-Reasonix` --- # Roo Code Source: https://docs.aicentos.com/fr/clients/roo-code Language: fr > Configurer un fournisseur OpenAI Compatible dans Roo Code avec la Base URL et la clé API aicentos Roo Code prend en charge nativement le provider OpenAI Compatible, qui se connecte directement à ce service. ## Installation Page d'installation officielle : [https://roocode.com/extension](https://roocode.com/extension) Avec VS Code ou une branche compatible, la façon la plus directe d'installer est : ```bash code --install-extension RooVeterinaryInc.roo-cline ``` Vous pouvez aussi rechercher directement `Roo Code` dans le marché d'extensions et installer le plugin officiel. ## Ouvrir la configuration du provider Dans le panneau Roo Code, ouvrez la page de réglages et accédez à la configuration du provider de modèles. ## Configuration à renseigner Réglez `API Provider` sur `OpenAI Compatible`, puis renseignez : * Base URL : `https://aicentos.com/v1` * API Key : votre clé (`codex_...`, `sk-...`, etc.) * Model ID : `gpt-5-codex-mini` Si le modèle n'est pas listé dans le menu déroulant, vous pouvez saisir directement le nom du modèle manuellement. ## Test Après enregistrement, lancez une nouvelle tâche et vérifiez que Roo Code se connecte normalement et commence à répondre. ## Remarques * La documentation officielle de Roo Code impose l'utilisation du provider `OpenAI Compatible` * Avec un provider compatible OpenAI, Roo Code dépend d'un modèle prenant en charge le tool calling natif * Pour ce service, il suffit de renseigner directement `https://aicentos.com/v1` comme Base URL * Documentation officielle de référence : [https://docs.roocode.com/providers/openai-compatible](https://docs.roocode.com/providers/openai-compatible) --- # Senpi (OmO Native) Source: https://docs.aicentos.com/fr/clients/senpi Language: fr > Connecter aicentos à Senpi / OmO — emplacement du répertoire de configuration et du provider openai-compatible Senpi est un fork de `pi-mono`, dont le paquet npm s'appelle `@code-yeongyu/senpi` et l'exécutable `senpi`. Il sert aussi de runtime à oh-my-openagent (OmO en abrégé), donc « OmO Native » désigne l'ensemble qui tourne sur le harness senpi. ## Prérequis ```bash curl -fsSL https://get.omo.dev/install.sh | bash omo ``` Vous pouvez aussi l'installer avec bun : ```bash bun add -g omo-ai ``` Le projet se décrit comme experimental ; les auteurs recommandent explicitement de ne pas le placer sur une chaîne de production. ## Configuration à renseigner Le répertoire de configuration est `~/.omo/agent/`, surchargeable via `OMO_CODING_AGENT_DIR` ; les anciennes variables `SENPI_*` restent compatibles. | Fichier | Rôle | | --------------- | ---------------------------------------------------------------- | | `models.json` | définition des providers (endpoint, protocole, liste de modèles) | | `auth.json` | clés | | `settings.json` | préférences, modèle par défaut, etc. | senpi lui-même dispose de son propre ensemble : `~/.senpi/agent/settings.json`, ainsi que `.senpi/settings.json` au niveau du projet. | Champ | Valeur | | --------------------- | ------------------------------------------------------------------- | | Protocole du provider | `@ai-sdk/openai-compatible` | | Base URL | `https://aicentos.com/v1` | | API Key | clé créée dans la console | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration Dans `~/.omo/agent/models.json`, ajoutez un provider et choisissez la catégorie compatible OpenAI comme protocole (le mapping donné par la documentation est `npm: @ai-sdk/openai-compatible`) : ```json { "providers": { "aicentos": { "npm": "@ai-sdk/openai-compatible", "options": { "baseURL": "https://aicentos.com/v1", "apiKey": "sk-votre-clé-API" }, "models": { "votre-nom-de-modèle": {} } } } } ``` La clé peut aussi être placée séparément dans `auth.json`, sans être écrite dans `models.json`. Écrivez ensuite le modèle par défaut dans `settings.json`. ## Test Lancez `omo` ou `senpi`, vérifiez dans le sélecteur de modèles que les modèles sous `aicentos` apparaissent, puis envoyez une phrase pour confirmer que la réponse arrive. ## Remarques * Ne mélangez pas les deux répertoires de configuration : côté OmO c'est `~/.omo/agent/`, côté senpi `~/.senpi/agent/` ; modifier le mauvais endroit n'a aucun effet. * Le `.senpi/settings.json` au niveau du projet écrase les réglages globaux : en cas de problème, regardez d'abord le répertoire du projet. * La documentation officielle ne fournit que le mapping de migration, sans extrait de configuration littéral complet ; la structure ci-dessus est organisée selon les conventions de la famille Pi, vérifiez les noms de champs avec la version actuelle de `omo.dev/docs`. * Projet experimental : la structure de configuration peut changer après une mise à niveau. ## Liens utiles * [Documentation OmO](https://omo.dev/docs) * [Dépôt senpi](https://github.com/code-yeongyu/senpi) * [Dépôt oh-my-openagent](https://github.com/code-yeongyu/oh-my-openagent) --- # SillyTavern Source: https://docs.aicentos.com/fr/clients/sillytavern Language: fr > Ajouter aicentos comme backend compatible OpenAI dans SillyTavern : Base URL et clé API pour utiliser tous les modèles disponibles # SillyTavern SillyTavern est une application de chat de roleplay populaire qui prend en charge plusieurs backends de modèles IA. En configurant une API compatible OpenAI, vous pouvez la connecter à ce service. ## Ouvrir les réglages de connexion API 1. Lancez l'application SillyTavern 2. Cliquez sur l'icône de connexion API en haut de l'interface 3. Choisissez **Chat Completion (OpenAI Compatible)** ## Renseigner les informations de connexion Dans le panneau de réglages API, renseignez : * **API Type** : choisissez `OpenAI` * **Chat Completion Source** : choisissez `OpenAI` ou `OpenAI Compatible` * **API URL** : `https://aicentos.com/v1` * **API Key** : saisissez votre clé API (par ex. `codex_...` ou `sk-...`) * **Model** : choisissez ou saisissez l'ID du modèle (par ex. `gpt-6-astra`) ## Tester la connexion 1. Cliquez sur le bouton **Connect** 2. Si la connexion réussit, l'état passe au vert 3. Vous pouvez alors discuter avec votre personnage ## Remarques * Il suffit de renseigner l'API URL jusqu'à `/v1`, sans le chemin complet * Les réponses en streaming sont prises en charge ; il est conseillé de les activer dans les réglages avancés * Vous pouvez saisir manuellement l'ID du modèle dans le menu déroulant des modèles ## Documentation officielle Consultez la [documentation officielle de SillyTavern](https://docs.sillytavern.app/) pour découvrir les autres options de configuration. --- # TavernAI Source: https://docs.aicentos.com/fr/clients/tavernai Language: fr > Configurer TavernAI sur l’API compatible OpenAI d’aicentos : Base URL et clé API pour démarrer la conversation # TavernAI TavernAI est une application de chat de roleplay qui permet de se connecter à un service API personnalisé via une interface compatible OpenAI. ## Ouvrir les réglages 1. Lancez l'application TavernAI 2. Cliquez sur l'icône de réglages en haut à droite 3. Trouvez la section **API Settings** ou **AI Configuration** ## Configurer la connexion API Dans les réglages API, renseignez : * **API Type** : choisissez `OpenAI` * **API Endpoint** : `https://aicentos.com/v1` * **API Key** : saisissez votre API Key (par ex. `codex_...` ou `sk-...`) * **Model** : saisissez l'ID du modèle (par ex. `gpt-6-astra`) ## Enregistrer et tester 1. Cliquez sur **Save** pour enregistrer les réglages 2. Revenez à l'interface de chat 3. Envoyez un message pour tester la connexion ## Remarques * L'interface de TavernAI peut varier légèrement selon les versions * Veillez à ce que l'API Endpoint se termine bien par `/v1` * En cas d'échec de connexion, vérifiez que l'API Key est correcte ## Liens utiles TavernAI est un projet communautaire ; vous trouverez la documentation associée et le support sur GitHub. --- # Trae Source: https://docs.aicentos.com/fr/clients/trae Language: fr > Ajouter un service compatible OpenAI dans les réglages de Trae, avec la Base URL aicentos et la clé API Ce document explique comment se connecter à ce service depuis Trae via une configuration personnalisée compatible OpenAI. Les points d'entrée des réglages varient selon les versions de Trae ; plutôt que de suivre un chemin de menu unique, ce document indique les options de configuration clés que vous devez trouver. ## Ouvrir les réglages AI / Model Dans les réglages de Trae, cherchez les zones de configuration correspondant aux mots-clés suivants : * AI * Models * Provider * OpenAI * Custom Si la version en cours prend en charge la connexion personnalisée compatible OpenAI, elle propose généralement des champs pour le fournisseur de modèles, la clé API et la Base URL. ## Configuration à renseigner Renseignez selon ce service : * Base URL : [https://aicentos.com/v1](https://aicentos.com/v1) * Clé API : votre clé `codex_...` ou `sk-...` * Model ID : conformez-vous au résultat de GET /v1/models ; pour un simple test de connectivité, vous pouvez d'abord essayer gpt-6-astra ## Test Après enregistrement, créez une nouvelle conversation, une tâche d'édition ou une tâche d'agent, et vérifiez que Trae envoie bien les requêtes et en reçoit le contenu. ## Remarques * Il s'agit d'une Base URL compatible OpenAI : n'y ajoutez pas le chemin complet /chat/completions ni /responses * Si votre version ne permet de choisir que les modèles officiels intégrés, ou n'accepte qu'une clé OpenAI officielle sans modifier la Base URL, la connexion directe à cette passerelle est impossible * L'approche la plus sûre consiste à confirmer d'abord les modèles visibles avec GET /v1/models, puis à renseigner le Model ID dans Trae --- # Unsloth Source: https://docs.aicentos.com/fr/clients/unsloth Language: fr > Unsloth est un framework de fine-tuning et d'inférence locale, pas un client de chat — pourquoi il ne peut pas se connecter à aicentos Unsloth est un framework open source de fine-tuning et d'inférence locale, accompagné d'une application de bureau et d'Unsloth Studio (interface navigateur). Son panneau `Connections` ressemble à des « réglages de fournisseur de modèles », mais **il n'accepte que des endpoints locaux ou auto-hébergés, les fournisseurs cloud formant une liste figée** : il n'y a pas d'option « URL compatible OpenAI quelconque », et il est donc impossible de diriger les requêtes d'inférence vers aicentos. ## Pourquoi une connexion directe est impossible * Dans `Settings → Connections → Add Provider` de Studio, les choix disponibles sont des **services locaux ou auto-hébergés** comme llama.cpp, vLLM ou Ollama, avec une Base URL du type `http://localhost:8000/v1`. * Côté cloud, c'est une liste figée (OpenAI, Anthropic, OpenRouter, ChatGPT/Codex) + clé API, sans entrée pour un endpoint personnalisé. * Dans la documentation officielle, « remote OpenAI-compatible endpoint » désigne un service d'inférence **que vous déployez vous-même**, pas une passerelle d'agrégation tierce. * Son orientation est aussi celle d'un serveur : Unsloth expose lui-même une API compatible OpenAI, destinée à ce que d'autres s'y connectent. ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | API Key | clé créée dans la console | | Base URL | `https://aicentos.com/v1` | | Modèle | nom du modèle dans la « place de marché des modèles » de la console | Le tableau ci-dessus regroupe les paramètres génériques côté aicentos, utilisables par les alternatives ci-dessous. ## Alternatives ### Option 1 : l'entraînement d'un côté, le chat de l'autre Utilisez Unsloth pour le fine-tuning et l'inférence locale, et un client comme [Cherry Studio](https://docs.aicentos.com/fr/clients/cherry-studio) ou [Chatbox](https://docs.aicentos.com/fr/clients/chatbox) connecté à aicentos pour les conversations quotidiennes. Les deux ne se gênent pas. ### Option 2 : lancer un service local et y connecter un front-end Unsloth expose une interface compatible OpenAI. Une fois le service `unsloth` lancé en local, renseignez la Base URL du client sur son adresse (par exemple `http://localhost:8000/v1`) : c'est la même manipulation que pour aicentos. ### Option 3 : pour comparer les résultats, changez de front-end Pour comparer « un modèle affiné localement » et « un modèle généraliste sur aicentos », le plus simple est un client acceptant plusieurs providers simultanés, avec bascule dans la même interface. ## Test Une fois le service local démarré, vérifiez d'abord que l'interface répond avec `curl http://localhost:8000/v1/models`, puis envoyez une invite dans le client. ## Remarques * Ne prenez pas `Connections` de Studio pour un panneau BYOK : il gère le runtime local. * L'inférence locale consomme du matériel ; pour les contextes longs et les gros lots, préférez aicentos. * La documentation officielle ne décrit pas de processus « générer des données d'entraînement avec une API tierce » : ne planifiez pas votre pipeline sur cette idée. ## Liens utiles * [Documentation Unsloth Connections](https://unsloth.ai/docs/integrations/connections) * [Dépôt unsloth](https://github.com/unslothai/unsloth) --- # Warp Source: https://docs.aicentos.com/fr/clients/warp Language: fr > Connecter aicentos à Warp : piloter Warp Agent via un point de terminaison d'inférence personnalisé Warp est un environnement de développement d'agents en forme de terminal. Il prend en charge les **Custom inference endpoints** : dès lors que l'interlocuteur implémente l'interface OpenAI Chat Completions, les appels de modèles de Warp Agent peuvent lui être transférés. Pointez le point de terminaison vers aicentos pour piloter l'Agent de Warp avec les modèles de votre propre compte. ## Prérequis * Mettez Warp à jour vers une version incluant les points de terminaison d'inférence personnalisés (les versions anciennes ne proposent que le BYOK, sans Base URL modifiable). * Créez une clé dédiée dans la console aicentos (nommez-la par exemple `warp-terminal`). * Vérifiez que les modèles à utiliser prennent en charge **l'appel d'outils (function calling)**, dont Warp Agent dépend pour lire et écrire des fichiers et exécuter des commandes. ## Configuration à renseigner | Champ | Valeur | | ------------- | --------------------------------------------------------------------------- | | Endpoint name | `aicentos` (personnalisé, sert à l'identifier dans le sélecteur de modèles) | | Endpoint URL | `https://aicentos.com/v1` | | API Key | clé créée dans la console | | Model name | ID du modèle dans la « place de marché des modèles » de la console | | Model alias | facultatif, nom affiché dans le sélecteur de modèles | ## Étapes de configuration * Ouvrez les réglages de Warp, recherchez `inference endpoint`, ou rendez-vous dans **Settings → AI**. * Dans la zone **Custom inference**, cliquez sur **Add custom model** / **Add destination**. * Dans la fenêtre qui s'ouvre, renseignez Endpoint name, Endpoint URL (`https://aicentos.com/v1`) et API Key. * Dans **Model name**, saisissez l'ID du modèle, cliquez sur **Add model** pour en ajouter d'autres ; un alias peut être renseigné pour faciliter l'identification. * Après enregistrement, le modèle personnalisé apparaît dans le sélecteur de modèles de Warp, identifié par le nom de votre point de terminaison. ## Test Dans Warp, sélectionnez le modèle que vous venez d'ajouter et posez une question simple (par ex. « liste les fichiers du répertoire courant et explique la structure du projet ») pour vérifier que la réponse arrive normalement. Les modèles de points de terminaison personnalisés apparaissent dans le sélecteur du mode agent, de la barre d'outils et de l'ambient agent. ## Remarques * L'Endpoint URL prend le chemin racine compatible OpenAI (de quoi composer `/v1/chat/completions`), ne l'écrivez pas en chemin complet `/v1/chat/completions`. * Le point de terminaison doit être accessible depuis **l'Internet public** : les requêtes de Warp transitent par ses serveurs, `localhost` et les adresses intranet sont refusées. `aicentos.com` est une adresse HTTPS publique, directement utilisable. * L'API Key et les informations du point de terminaison sont stockées dans le coffre sécurisé de **l'appareil local** ; les serveurs de Warp ne les utilisent qu'à la volée lors des requêtes, sans les conserver. * Les requêtes passant par un point de terminaison personnalisé **ne consomment pas les AI credits de Warp**, la facturation se fait côté aicentos à l'usage ; mais en offre Business / Enterprise, l'exécution locale d'agents continue de consommer des credits de plateforme. * En cas d'erreur `400 invalid model format`, votre passerelle exige la forme `provider/model_id` ; référez-vous à l'ID de modèle donné par la console et ajoutez si nécessaire le préfixe dans ce format. * Les points de terminaison personnalisés ne permettent pas, à ce jour, de déclarer séparément la fenêtre de contexte ; les sessions très longues peuvent être compressées par anticipation. * Documentation officielle : `https://docs.warp.dev/agent-platform/inference/custom-inference-endpoint/` --- # Windsurf Source: https://docs.aicentos.com/fr/clients/windsurf Language: fr > Saisir l’endpoint et la clé API aicentos dans Windsurf, si votre version accepte une Base URL personnalisée Ce document explique comment se connecter à ce service depuis Windsurf via une configuration personnalisée compatible OpenAI. Les capacités de BYOK et de configuration de modèles personnalisés ne sont pas identiques d'une version de Windsurf à l'autre ; deux cas sont donc distingués ci-dessous. ## Vérifier d'abord que votre version accepte une Base URL personnalisée Dans les réglages de modèles, d'abonnement ou d'IA de Windsurf, cherchez des entrées du type : * `Models` * `BYOK` * `OpenAI` * `Custom` * `Base URL` Si vous ne pouvez saisir qu'une clé API officielle, sans Base URL éditable, cette version se limite généralement au mode BYOK officiel et ne peut pas être réorientée vers cette passerelle. ## Renseigner les informations de connexion personnalisées Si votre version propose une configuration personnalisée compatible OpenAI, renseignez : * Base URL : `https://aicentos.com/v1` * Clé API : votre clé `codex_...` ou `sk-...` * Model ID : conformez-vous au résultat de `GET /v1/models` ; pour un simple test de connectivité, vous pouvez d'abord essayer `gpt-6-astra` ## Test Après enregistrement des réglages, créez une nouvelle conversation Cascade ou une tâche de codage et vérifiez que le résultat revient normalement. ## Remarques * La Base URL doit être `https://aicentos.com/v1` * N'écrivez pas le chemin complet `/v1/chat/completions` ni `/v1/responses` * Si votre version n'ouvre que le BYOK officiel, sans Base URL personnalisée, la connexion directe à cette passerelle est impossible * Page officielle de Windsurf sur les modèles : `https://docs.windsurf.com/windsurf/models` --- # WorkBuddy Source: https://docs.aicentos.com/fr/clients/workbuddy Language: fr > Utiliser aicentos dans WorkBuddy : connexion via une configuration personnalisée compatible OpenAI WorkBuddy accepte la configuration d'un modèle personnalisé compatible OpenAI. Pointez la Base URL vers aicentos et renseignez la clé API pour que WorkBuddy utilise les modèles intégrés par aicentos. ## Prérequis Créez une clé dédiée dans la console aicentos (nommez-la par exemple `workbuddy`, pour suivre plus facilement sa consommation). ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | Provider | `OpenAI Compatible` | | Clé API | clé créée dans la console | | Base URL | `https://aicentos.com/v1` | | Model ID | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration * Ouvrez les réglages de modèles / IA de WorkBuddy. * Réglez le Provider sur **OpenAI Compatible** (ou « personnalisé »). * Renseignez la clé API créée dans la console aicentos. * Réglez la Base URL sur : `https://aicentos.com/v1` * Renseignez l'ID du modèle (voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list)), en le saisissant manuellement si nécessaire. * Enregistrez les réglages. ## Test Après enregistrement, créez une nouvelle conversation et envoyez une invite simple pour vérifier que la connexion s'établit et que le contenu revient normalement. ## Remarques * La Base URL s'arrête à `/v1`, ne la complétez pas en chemin complet `/chat/completions`. * Si votre version n'expose pas de Base URL éditable et n'accepte qu'une clé officielle, la connexion directe à cette passerelle est impossible ; il faudra passer à un client acceptant un point d'accès personnalisé. * Il est conseillé de vérifier d'abord les modèles visibles avec `GET /v1/models` avant de renseigner le Model ID dans WorkBuddy. * En cas de solde insuffisant, les requêtes échouent ; vérifiez d'abord le solde sur la [page du portefeuille](https://aicentos.com/wallet). --- # ZCode Source: https://docs.aicentos.com/fr/clients/zcode Language: fr > Utiliser aicentos dans ZCode : connexion via une configuration personnalisée compatible OpenAI ZCode prend en charge une configuration de modèle personnalisée compatible OpenAI. Pointez la Base URL vers aicentos et renseignez l'API Key pour utiliser, dans les conversations et les tâches de codage de ZCode, les modèles intégrés par aicentos. ## Prérequis Créez une clé dédiée dans la console aicentos (nommez-la par exemple `zcode`, pour suivre plus facilement sa consommation). ## Configuration à renseigner | Champ | Valeur | | -------- | ------------------------------------------------------------------- | | Provider | `OpenAI Compatible` | | API Key | clé créée dans la console | | Base URL | `https://aicentos.com/v1` | | Model ID | nom du modèle dans la « place de marché des modèles » de la console | ## Étapes de configuration * Ouvrez les réglages de ZCode et rendez-vous dans la zone de configuration des modèles / IA. * Trouvez les options relatives au Provider et choisissez **OpenAI Compatible** (ou « OpenAI personnalisé »). * Renseignez l'API Key créée dans la console aicentos. * Réglez la Base URL sur : `https://aicentos.com/v1` * Renseignez l'ID du modèle (voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list)) ; si le modèle visé n'apparaît pas dans la liste déroulante, saisissez-le manuellement. * Enregistrez les réglages ; si un bouton **Verify** est proposé, cliquez d'abord dessus une fois. ## Test Créez une nouvelle conversation ou une tâche de codage, envoyez une invite simple et vérifiez que le contenu revient normalement. ## Remarques * La Base URL s'arrête à `/v1`, ne la complétez pas en chemin complet `/chat/completions` ou `/v1/responses`. * Si votre version n'accepte que les modèles officiels intégrés, sans Base URL éditable, la connexion directe à cette passerelle est impossible ; il faudra alors passer à un client prenant en charge les points de terminaison personnalisés. * Il est conseillé de vérifier d'abord les modèles visibles avec `GET /v1/models` avant de renseigner le Model ID dans ZCode. * En cas de solde insuffisant, les requêtes échouent ; vérifiez d'abord le solde sur la [page du portefeuille](https://aicentos.com/wallet). --- # Zed Agent Source: https://docs.aicentos.com/fr/clients/zed-agent Language: fr > Connecter aicentos à l'Agent Panel de Zed via un provider compatible OpenAI Zed intègre un type de provider compatible OpenAI : en déclarant le point d'accès, les modèles et la longueur de contexte dans `settings.json`, l'Agent Panel peut utiliser les modèles intégrés par aicentos. ## Prérequis Créez d'abord dans la console, page « Clés API », une clé dédiée pour Zed (nommez-la par exemple `zed-agent`). * Console : [https://aicentos.com](https://aicentos.com) * Créer une clé : [https://aicentos.com/keys](https://aicentos.com/keys) * Recharger le portefeuille : [https://aicentos.com/wallet](https://aicentos.com/wallet) Zed n'écrit pas la clé API dans `settings.json` : il lit une variable d'environnement homonyme. L'ID du provider est converti en majuscules avec des underscores, auquel s'ajoute le suffixe `_API_KEY`. Ainsi, avec l'ID de provider `aicentos`, la variable d'environnement s'appelle `AICENTOS_API_KEY`. ## Configuration à renseigner | Champ | Valeur | | ------------------------------- | ------------------------------------------------------------------- | | Provider ID | personnalisé, par ex. `aicentos` | | `api_url` | `https://aicentos.com/v1` | | `available_models[].name` | nom du modèle dans la « place de marché des modèles » de la console | | `available_models[].max_tokens` | fenêtre de contexte du modèle | | Clé API | variable d'environnement `AICENTOS_API_KEY` | ## Étapes de configuration * Ouvrez le `settings.json` de Zed (commande `zed: open settings` dans la palette de commandes). * Ajoutez la configuration `language_models.openai_compatible` : ```json { "language_models": { "openai_compatible": { "aicentos": { "api_url": "https://aicentos.com/v1", "available_models": [ { "name": "gpt-5", "display_name": "GPT-5 (aicentos)", "max_tokens": 128000, "max_output_tokens": 16384, "capabilities": { "tools": true, "images": false, "chat_completions": true } } ] } } } } ``` * Exportez la variable d'environnement (écrivez-la dans `~/.zshrc` puis rechargez) : ```bash export AICENTOS_API_KEY="sk-votre-clé-aicentos" ``` * Ouvrez l'Agent Panel et sélectionnez dans le menu déroulant des modèles un modèle de ce provider. Vous pouvez aussi cliquer sur **Add Provider** dans les réglages de l'Agent et renseigner via l'interface graphique le nom du provider, l'URL API, l'ID du modèle et la fenêtre de contexte. ## Test Une fois la configuration terminée, créez une nouvelle conversation dans l'Agent Panel et faites d'abord un test léger avec une invite simple ; ne passez aux appels d'outils qu'une fois les retours confirmés. ## Remarques * `api_url` s'arrête à `https://aicentos.com/v1`, ne le complétez pas en chemin complet `/chat/completions` ; Zed construit lui-même le chemin. * La clé API ne doit pas être écrite directement dans `settings.json` : utilisez une variable d'environnement (ou enregistrez-la via l'interface de réglages du provider dans le trousseau système) ; une variable d'environnement non vide prime sur le trousseau. * `max_tokens` correspond à la fenêtre de contexte ; renseignez la valeur réelle du modèle, car une absence entraîne une gestion anormale du contexte. * Les appels d'outils sont activés par défaut (`capabilities.tools`) ; la saisie d'images et les appels d'outils parallèles sont désactivés par défaut, à activer manuellement si besoin. * Documentation officielle : [https://zed.dev/docs/ai/llm-providers](https://zed.dev/docs/ai/llm-providers) * Pour plus de détails, consultez le site de documentation : [https://docs.aicentos.com](https://docs.aicentos.com) --- # Présentation d’aicentos Source: https://docs.aicentos.com/fr/introduction Language: fr > Une seule API pour tous les LLM — agrégation d’OpenAI, Anthropic, Google, xAI et d’autres grands fournisseurs **aicentos** est une plateforme d’agrégation d’API d’IA pour les développeurs. Une seule clé API pour appeler les LLM d’OpenAI, Anthropic, Google, xAI, DeepSeek et d’autres grands fournisseurs. Site aicentos ## Le problème que nous résolvons Qu’est-ce qui rend l’intégration des LLM pénible ? Inscriptions séparées, clés séparées, facturation séparée, SDK séparés. aicentos aplatit tout cela. | Point de douleur | Approche traditionnelle | aicentos | | --------------------------- | -------------------------------- | ----------------------------------------------- | | Changer de modèle | Modifier SDK, URL et clé | **Changer un seul paramètre `model`** | | Comptes à l’étranger | Carte bancaire / numéro étranger | **¥1 offerts à l’inscription, recharge Alipay** | | Spécifications API | Une par fournisseur | **Protocole unifié compatible OpenAI** | | Transparence de facturation | Tableaux de bord séparés | **Facturation et journaux d’usage unifiés** | | Gouvernance des clés | Pas de permissions fines | **Quotas, listes de modèles, règles IP** | La console réunit clés, solde, usage et journaux en un seul endroit : Vue de la console ## Fonctionnalités clés ### Accès multi-fournisseurs OpenAI, Anthropic, Google, xAI, Alibaba Qwen, DeepSeek, Zhipu, Moonshot, MiniMax — **tous derrière un seul endpoint** : chat, raisonnement, code, image, vidéo et embeddings. Les nouveaux modèles sont adaptés au fur et à mesure ; vos appels SDK restent inchangés. Voir [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list) pour la liste complète. ### Disponibilité vérifiable Chaque modèle dispose de ses propres contrôles de santé. Sur le [moniteur de statut](https://docs.aicentos.com/status), consultez la disponibilité 1 h / 24 h / 7 j, la latence et le PING des endpoints avant d’intégrer. ### Sécurité intégrée Les clés API prennent en charge **quotas, listes de modèles autorisés, règles IP et dates d’expiration**, émises par projet ou par membre pour le suivi des coûts et la révocation des accès. ### Pensé pour les développeurs Entièrement **compatible OpenAI**. Les projets OpenAI / Codex existants fonctionnent après avoir remplacé `base_url` par `https://aicentos.com/v1` ; Claude / Anthropic et les autres protocoles utilisent la racine `https://aicentos.com` — **zéro ligne de code à migrer**. ## À qui ça s’adresse * Les développeurs qui veulent **Claude / GPT / Gemini** sans compte étranger ni carte bancaire * Les chercheurs / développeurs d’agents qui **comparent plusieurs LLM** * Les équipes qui exigent **facturation / quotas / audit d’usage unifiés** * Les ingénieurs confrontés à une **latence élevée / des liaisons instables** vers les API étrangères ## Chiffres de la plateforme | Indicateur | Valeur | | ------------------- | ---------------: | | Bonus d’inscription | **¥1 de crédit** | | Expiration du solde | **Jamais** | ## Prochaines étapes * [Démarrage rapide](https://docs.aicentos.com/fr/quickstart) — trois étapes vers votre premier appel * [Modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list) — la liste complète des modèles * [Moniteur de statut](https://docs.aicentos.com/status) — disponibilité en temps réel par modèle * [Facturation](https://docs.aicentos.com/fr/billing/pricing) — recharges et facturation à l’usage --- # Génération d’images Nano Banana 2 Source: https://docs.aicentos.com/fr/nano-banana2 Language: fr > Générez des images avec gemini-3.1-flash-image-preview (Nano Banana 2) via aicentos — exemples aux formats natif Gemini et compatible OpenAI Cette page montre des exemples de requêtes pour générer des images avec **Nano Banana 2** (`gemini-3.1-flash-image-preview`) via aicentos, avec deux formats d’entrée : **format natif Gemini** et **format compatible OpenAI**. `imageConfig` permet de préciser le format d’image (`aspectRatio`) et la résolution (`imageSize`, par ex. `2K`, `4K`). ## Format natif Gemini Exemple de requête pour une image 4K au format 1:1 : ```bash export AICENTOS_API_KEY="sk-votre-clé-API" curl --location --request POST 'https://aicentos.com/v1beta/models/gemini-3.1-flash-image-preview:generateContent' \ --header "x-goog-api-key: $AICENTOS_API_KEY" \ --header 'content-type: application/json' \ --header 'Accept: */*' \ --data-raw '{ "contents": [ { "parts": [ { "text": "Style d’affiche publicitaire rétro, texte chinois mis en avant, fond à motif radial rouge et jaune. Au centre de l’image, une belle jeune femme dessinée dans un style rétro raffiné, souriante, élégante et avenante. Le thème est la promotion d’un tout nouveau service de peinture par IA, résolution 4K\n" } ] } ], "generationConfig": { "responseModalities": [ "image" ], "imageConfig": { "aspectRatio": "1:1", "imageSize": "4K" } } }' ``` ## Format compatible OpenAI Exemple de requête pour une image 2K au format 9:16 : ```bash export AICENTOS_API_KEY="sk-votre-clé-API" curl --location --request POST 'https://aicentos.com/v1/chat/completions' \ --header "Authorization: Bearer $AICENTOS_API_KEY" \ --header 'Content-Type: application/json' \ --header 'Accept: */*' \ --data-raw '{ "model": "gemini-3.1-flash-image-preview", "extra_body": { "imageConfig": { "aspectRatio": "9:16", "imageSize": "2K" } }, "messages": [ { "role": "system", "content": "{\"imageConfig\": {\"aspectRatio\": \"9:16\", \"imageSize\": \"2K\"}}" }, { "role": "user", "content": [ { "type": "text", "text": "Dessine une illustration de vœux pour l’année du Cheval" } ] } ], "max_tokens": 4096, "temperature": 0.8 }' ``` ## Paramètres * `aspectRatio` : format d’image, par ex. `1:1`, `9:16`, `16:9`. * `imageSize` : résolution, par ex. `2K`, `4K`. * Le format natif Gemini s’authentifie avec `x-goog-api-key` ; le format compatible OpenAI, avec `Authorization: Bearer`. * En format compatible OpenAI, `imageConfig` peut être placé dans `extra_body` ou dans le JSON du message `system`. * Remplacez `sk-votre-clé-API` dans les exemples par la clé API créée dans votre console aicentos. --- # Démarrage rapide Source: https://docs.aicentos.com/fr/quickstart Language: fr > Intégration en trois étapes : créer un compte → générer une clé API → renseigner Base URL et clé dans votre client Intégration en trois étapes : **créer un compte → générer une clé API → renseigner la Base URL et la clé dans votre client**. ## Étape 1 : créer un compte Ouvrez [aicentos.com](https://aicentos.com/) et cliquez sur « **Commencer** » en haut à droite pour accéder à la page d’inscription : Page d’inscription Renseignez **nom d’utilisateur** et **mot de passe**, acceptez les conditions d’utilisation puis cliquez sur « Créer un compte ». L’inscription offre **¥1** de crédit d’essai, utilisable sans recharger au préalable. ## Étape 2 : créer une clé API Une fois connecté, ouvrez la console, cliquez sur « **Clés API** » dans la navigation de gauche, puis sur « **Créer une clé API** » en haut à droite : Page des clés API Renseignez la configuration dans la fenêtre qui s’ouvre puis cliquez sur « Enregistrer les modifications » : Créer une clé API | Champ | Description | | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------- | | Nom | Personnalisable, pour distinguer plusieurs projets. Créez une clé par usage afin de faciliter le suivi des coûts et la révocation des droits | | Groupe | Choisissez le groupe amont à emprunter ; laissez vide pour utiliser le groupe par défaut | | Expiration | « Jamais d’expiration » ou une durée de 1 heure / 1 jour / 1 mois | | Quantité | Crée plusieurs clés d’un coup ; un suffixe aléatoire est ajouté aux noms | | Quota illimité | Une fois désactivé, permet de plafonner le quota de cette clé | Une fois créée, la clé apparaît dans la liste sous la forme `sk-xxxxxxxxxxxx`, masquée par défaut : Clé créée La liste des clés permet de rechercher par nom et par clé, d’afficher groupe, quota, modèles disponibles, restrictions IP, etc., et de modifier ou supprimer à tout moment : Liste des clés > **La clé ne s’affiche complète qu’une seule fois, à sa création** : copiez-la immédiatement et conservez-la soigneusement. Ne la codez pas en dur dans du code front-end et ne la commitez pas dans un dépôt public. ## Étape 3 : renseigner Base URL et clé dans votre client ### Bien choisir la Base URL C’est l’étape qui cause le plus d’erreurs — **l’adresse diffère selon le protocole** : | Cas d’usage | Base URL | | ------------------------------------------------- | ------------------------- | | Codex / format compatible OpenAI | `https://aicentos.com/v1` | | Claude Code / format Anthropic, et autres clients | `https://aicentos.com` | > **Avec le protocole Anthropic, renseignez uniquement l’adresse racine** : n’ajoutez pas manuellement `/v1/messages`, le client l’ajoute lui-même. Le menu déroulant « **Adresse API** » en haut à droite de la page « Clés API » de la console permet aussi de consulter et de copier ces adresses : Adresse API ### Vérifier la connectivité Lancez une requête minimale avec curl pour confirmer que la clé et le réseau fonctionnent : ```bash export AICENTOS_API_KEY="sk-votre-clé" curl https://aicentos.com/v1/chat/completions \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -d '{ "model": "gemini-3.8-flash", "messages": [ {"role": "user", "content": "Présente-toi en une phrase"} ] }' ``` Vous pouvez d’abord interroger la liste des modèles. Si du JSON est renvoyé, la clé et la Base URL sont opérationnelles : ```bash export AICENTOS_API_KEY="sk-votre-clé" curl https://aicentos.com/v1/models \ -H "Authorization: Bearer $AICENTOS_API_KEY" ``` ### Python (SDK OpenAI) ```python import os from openai import OpenAI client = OpenAI( api_key=os.environ["AICENTOS_API_KEY"], base_url="https://aicentos.com/v1", ) resp = client.chat.completions.create( model="gemini-3.8-flash", messages=[{"role": "user", "content": "Présente-toi en une phrase"}], ) print(resp.choices[0].message.content) ``` ### Node.js (SDK OpenAI) L’exemple utilise la syntaxe ESM : le fichier doit porter l’extension `.mjs`, ou ajoutez `"type": "module"` dans `package.json` : ```js import OpenAI from 'openai'; const client = new OpenAI({ apiKey: process.env.AICENTOS_API_KEY, baseURL: 'https://aicentos.com/v1', }); const resp = await client.chat.completions.create({ model: 'gemini-3.8-flash', messages: [{ role: 'user', content: 'Présente-toi en une phrase' }], }); console.log(resp.choices[0].message.content); ``` ### Clients courants * [Intégrer Claude Code](https://docs.aicentos.com/fr/claude-code) — import en un clic via CC Switch ou configuration manuelle * [Intégrer Codex](https://docs.aicentos.com/fr/codex) — configuration graphique ou config.toml écrit à la main * [Intégrer Cursor](https://docs.aicentos.com/fr/cursor) — réglages personnalisés compatibles OpenAI * [Intégrer Cherry Studio](https://docs.aicentos.com/fr/cherry-studio) — ajouter un fournisseur compatible OpenAI ## Recharger Une fois le crédit offert épuisé, rechargez depuis « **Portefeuille** » dans la navigation de gauche de la console : Portefeuille Paliers de recharge et remises (**dès ¥100 de recharge, une remise s’applique : le montant payé est inférieur au montant rechargé**) : | Montant rechargé | Remise | Montant payé | | -------------------- | ------- | ------------ | | ¥1 / ¥10 / ¥20 / ¥50 | aucune | prix normal | | ¥100 | 1 % OFF | ¥99 | | ¥500 | 2 % OFF | ¥490 | | ¥1,000 | 3 % OFF | ¥970 | | ¥10,000 | 5 % OFF | ¥9,500 | Un montant personnalisé est aussi possible, tout comme l’échange de crédit via un code de recharge. Modes de paiement * **Modes de paiement** : Alipay, WeChat Pay, virement bancaire * **Le crédit n’expire jamais** ; la facturation suit la consommation réelle en tokens * Un programme de parrainage existe : après inscription via votre lien d’invitation, les deux parties reçoivent une récompense, transférable à tout moment vers le solde ## Consulter l’usage La rubrique « **Tableau de bord** » de la console détaille la consommation : Vue d’ensemble de la console Vous y verrez le solde actuel, l’usage total, le nombre de requêtes API et les tendances d’appel par modèle : Tableau de bord ## Essayer sans écrire de code Dans « **Chat** » en haut de la console, un playground intégré permet de choisir un modèle, d’envoyer des messages et d’ajuster le prompt en discutant : Playground ## Prochaines étapes * Testez les modèles directement dans le navigateur via le [playground](https://aicentos.com/playground), sans écrire de code * Parcourez les [modèles pris en charge](https://docs.aicentos.com/fr/billing/models-list) — pour voir quels LLM sont disponibles * Consultez la [gestion des erreurs](https://docs.aicentos.com/fr/billing/errors) — pour diagnostiquer les 401, soldes insuffisants, etc. * Découvrez les [règles de facturation](https://docs.aicentos.com/fr/billing/pricing) — facturation à l’usage et alertes de solde --- # Suivi du statut des modèles Source: https://docs.aicentos.com/fr/status Language: fr > Consultez en temps réel la disponibilité, la latence et le PING des endpoints Le panneau de supervision en direct est actuellement disponible sur la [page de statut en chinois](https://docs.aicentos.com/status) uniquement. --- # Génération vidéo Veo Source: https://docs.aicentos.com/fr/veo-video Language: fr > Appelez les modèles de génération vidéo Google Veo via aicentos — texte vers vidéo, image vers vidéo, première et dernière frame, images de référence Ce document s’adresse aux développeurs et explique comment appeler les modèles de génération vidéo Google Veo via aicentos. L’interface suit le format compatible avec l’API vidéo d’OpenAI (OpenAI Videos API) ; côté aval, il suffit d’utiliser le type de canal `openai`. ## Capacités des modèles La facturation est basée sur la durée de génération de la vidéo (en secondes). Le prix unitaire exact est celui affiché dans la console aicentos ; le débit final fait foi selon les enregistrements réels du système. ### Capacités officielles et périmètre ouvert par aicentos | Modèle | Durées prises en charge | Résolutions prises en charge | Format d’image | Audio | Remarques | | ------------------------------- | ----------------------- | ---------------------------- | -------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | `veo-3.1-generate-preview` | 4, 6, 8 | 720p, 1080p, 4k | 16:9, 9:16 | audio natif | 1080p et 4k sont limités à 8 secondes ; avec les capacités image (images de référence, première/dernière frame), 8 secondes sont recommandées. | | `veo-3.1-fast-generate-preview` | 4, 6, 8 | 720p, 1080p, 4k | 16:9, 9:16 | audio natif | 1080p et 4k sont limités à 8 secondes ; avec les capacités image (images de référence, première/dernière frame), 8 secondes sont recommandées. | Documentation de référence : * [Génération vidéo Veo de l’API Google Gemini](https://ai.google.dev/gemini-api/video) * [Images de référence Veo](https://ai.google.dev/gemini-api/video#reference_images) * [Première et dernière frame Veo](https://ai.google.dev/gemini-api/video#first_and_last_frame) * [Format d’image Veo](https://ai.google.dev/gemini-api/video#aspect_ratio) ### Format d’image | Modèle | 16:9 paysage | 9:16 portrait | Format par défaut | Recommandation | | ------------------------------- | -------------- | -------------- | ----------------- | ----------------------------------------------------------------------- | | `veo-3.1-generate-preview` | Pris en charge | Pris en charge | 16:9 | Le 4K exige 8 secondes ; l’extension vidéo n’est pas encore disponible. | | `veo-3.1-fast-generate-preview` | Pris en charge | Pris en charge | 16:9 | Le 4K exige 8 secondes ; l’extension vidéo n’est pas encore disponible. | La requête peut préciser le format via `metadata.aspectRatio` ou le champ de formulaire `aspectRatio` : ```bash { "metadata": { "aspectRatio": "9:16" } } ``` Si aucun `aspectRatio` n’est transmis explicitement, le système le déduit d’abord de `size` : par exemple `1280x720` donne 16:9 et `720x1280` donne 9:16. Si `size` n’est pas transmis non plus, l’amont utilise 16:9 par défaut. ### Audio | Modèle | Capacité audio officielle | generateAudio pris en charge | Recommandation | | ------------------------------- | ------------------------- | ---------------------------- | -------------------------------------------------------------------------------- | | `veo-3.1-generate-preview` | audio natif | Non | Ne transmettez pas `generateAudio` ; décrivez les effets sonores dans le prompt. | | `veo-3.1-fast-generate-preview` | audio natif | Non | Ne transmettez pas `generateAudio` ; décrivez les effets sonores dans le prompt. | La série Veo 3.1 génère nativement l’audio, mais la table de paramètres Veo de l’API Gemini actuelle n’expose pas `generateAudio` comme paramètre contrôlable. Transmettre ce champ peut renvoyer `INVALID_ARGUMENT` côté amont. Pour contrôler le contenu audio, décrivez dialogues, sons d’ambiance, effets ou style musical dans le prompt, par exemple : ```bash Un phare au bord de la mer au crépuscule, les vagues frappant les rochers, au loin un vent sourd et des cris d’oiseaux marins, lumière cinématographique, mouvement de caméra stable ``` ## Entrées image | Capacité | Veo officiel (Google) | Pris en charge par l’API aicentos | Remarques | | ------------------------------------------ | --------------------------------------------------- | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | | Vidéo à partir d’une image initiale unique | Oui | Oui | Téléversez 1 image via `input_reference` ; elle sert d’image de départ de la vidéo. | | Première/dernière frame ou interpolation | La série Veo 3.1 prend en charge image + lastFrame | Oui | Première frame via `input_reference`, dernière via `last_frame` ou `lastFrame`. Série Veo 3.1 et 8 secondes recommandés. | | Plusieurs images de référence | Jusqu’à 3 referenceImages sur la série Veo 3.1 | Oui | Téléversez via `reference_image`, `reference_images` ou `referenceImages` ; `referenceType` n’accepte que `asset`. 8 secondes recommandées. | | Extension vidéo | Veo 3.1 / Fast sait étendre une vidéo Veo existante | Pas encore pris en charge | L’API aicentos actuelle n’expose pas l’entrée vidéo officielle. | * Types MIME d’image pris en charge : `image/jpeg`, `image/png`, `image/webp`. Préférez un fichier ou du Base64 ; évitez de passer directement une URL d’image distante. * Attention en mode images de référence : l’amont n’y prend pas en charge `negativePrompt` et peut renvoyer `Negative prompt is not supported in your use case`. N’envoyez pas de `negativePrompt` avec des requêtes à images de référence. * Détail d’implémentation : dans l’API Gemini, les entrées image de Veo `predictLongRunning` utilisent `bytesBase64Encoded` + `mimeType`, et non l’`inlineData` du `generateContent` classique. aicentos convertit les images téléversées en multipart vers le format attendu par l’amont. ## Règles de facturation * Facturation à la durée de génération, en secondes. Utilisez les durées prises en charge par le modèle (tableau ci-dessus) ; évitez de passer des durées arbitraires. * Si la requête ne précise pas de durée, la facturation est établie par défaut sur 8 secondes. * Ordre de priorité de lecture de la durée : `metadata.durationSeconds` > `duration` > `seconds` > 8 secondes par défaut. * Ordre de priorité de lecture de la résolution : `metadata.resolution` > `size` > 720p par défaut. * 720p / 1080p / 4K sont facturés selon les mêmes règles ; aucune majoration liée à la résolution. * `aspectRatio` ne contrôle que l’orientation (paysage ou portrait) ; aucune majoration. * Le 4K n’est possible qu’en 8 secondes. * Le prix unitaire exact est celui de la console aicentos. ## Endpoints Trois endpoints sont recommandés aujourd’hui : | Usage | Méthode | Chemin | | ----------------------- | ------- | ------------------------------ | | Créer une tâche | POST | `/v1/videos` | | Consulter le statut | GET | `/v1/videos/{task_id}` | | Télécharger le résultat | GET | `/v1/videos/{task_id}/content` | Pour obtenir directement l’URL du résultat lors de l’interrogation, vous pouvez aussi utiliser : | Usage | Méthode | Chemin | | ------------------------- | ------- | --------------------------------- | | Statut et URL du résultat | GET | `/v1/video/generations/{task_id}` | ### Authentification ```bash export BASE_URL="https://aicentos.com" export AICENTOS_API_KEY="sk-xxxxxx" ``` Toutes les requêtes incluent : ```bash -H "Authorization: Bearer $AICENTOS_API_KEY" ``` ### Créer une tâche texte vers vidéo ```bash curl -X POST "$BASE_URL/v1/videos" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "veo-3.1-generate-preview", "prompt": "Un phare au bord de la mer au crépuscule, lent travelling avant, les vagues frappant les rochers, lumière cinématographique, mouvement de caméra stable", "seconds": "8", "size": "1280x720", "metadata": { "negativePrompt": "blurry, watermark, distorted, low quality", "resolution": "720p", "aspectRatio": "16:9", "seed": 20260401 } }' ``` Réponse type : ```bash { "id": "task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "task_id": "task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "object": "video", "model": "veo-3.1-generate-preview", "status": "queued", "progress": 0, "created_at": 1775025000 } ``` ### Créer une tâche image vers vidéo (première frame) Pour l’image vers vidéo, `multipart/form-data` est recommandé ; le champ de la première frame doit impérativement s’appeler `input_reference`. ```bash curl -X POST "$BASE_URL/v1/videos" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Accept: application/json" \ -F "model=veo-3.1-generate-preview" \ -F "prompt=La fille se tourne vers la caméra, une brise légère soulève ses cheveux, les lumières de la ville en arrière-plan légèrement floutées, caméra avançant en douceur" \ -F "input_reference=@./first-frame.png;type=image/png" \ -F "seconds=8" \ -F "size=1280x720" \ -F "resolution=720p" \ -F "aspectRatio=16:9" \ -F "negativePrompt=blurry, watermark, deformed hands" \ -F "seed=20260401" ``` ### Créer une tâche première/dernière frame Cette tâche exige à la fois la première et la dernière frame. Première frame via `input_reference`, dernière via `last_frame` ou `lastFrame`. ```bash curl -X POST "$BASE_URL/v1/videos" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Accept: application/json" \ -F "model=veo-3.1-generate-preview" \ -F "prompt=Transition naturelle de la première image (fille) à la dernière (garçon), travelling avant régulier, lumières de ville floutées, cheveux et vêtements légèrement animés par le vent, transition fluide et réaliste" \ -F "input_reference=@./first-frame.png;type=image/png" \ -F "last_frame=@./last-frame.png;type=image/png" \ -F "seconds=8" \ -F "size=1280x720" \ -F "resolution=720p" \ -F "aspectRatio=16:9" \ -F "negativePrompt=blurry, watermark, distorted face, deformed hands" \ -F "seed=20260402" ``` ### Créer une tâche avec images de référence Les tâches avec images de référence ne sont possibles que sur la série Veo 3.1, 3 images maximum, avec `referenceType` limité à `asset`. Les noms de champ acceptés sont `reference_image`, `reference_images` ou `referenceImages`. N’envoyez pas de `negativePrompt` sur ces tâches. ```bash curl -X POST "$BASE_URL/v1/videos" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -H "Accept: application/json" \ -F "model=veo-3.1-generate-preview" \ -F "prompt=En s’appuyant sur l’apparence des personnages et l’ambiance nocturne urbaine des deux images, générer un plan de rue cinématographique en duo, travelling avant régulier, lumières d’arrière-plan légèrement floutées, personnages regardant naturellement la caméra" \ -F "reference_image=@./ref-1.png;type=image/png" \ -F "reference_image=@./ref-2.png;type=image/png" \ -F "reference_type=asset" \ -F "seconds=8" \ -F "size=1280x720" \ -F "resolution=720p" \ -F "aspectRatio=16:9" \ -F "seed=20260403" ``` Le JSON / Base64 est aussi accepté : ```bash { "model": "veo-3.1-generate-preview", "prompt": "Générer un plan publicitaire à partir de l’apparence du produit des images de référence", "duration": 8, "metadata": { "resolution": "720p", "aspectRatio": "16:9", "referenceImages": [ { "image": { "bytesBase64Encoded": "BASE64_IMAGE", "mimeType": "image/png" }, "referenceType": "asset" } ] } } ``` ### Consulter le statut d’une tâche Conservez d’abord l’`id` ou le `task_id` renvoyé par l’appel de création : ```bash export TASK_ID="task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" ``` Puis interrogez le statut : ```bash curl -X GET "$BASE_URL/v1/videos/$TASK_ID" \ -H "Authorization: Bearer $AICENTOS_API_KEY" ``` Pendant le traitement, réponse type : ```bash { "id": "task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "object": "video", "model": "veo-3.1-generate-preview", "status": "in_progress", "progress": 50, "created_at": 1775025000 } ``` À la fin, réponse type : ```bash { "id": "task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "object": "video", "model": "veo-3.1-generate-preview", "status": "completed", "progress": 100, "created_at": 1775025000, "completed_at": 1775025068 } ``` ### Consulter le statut et l’URL du résultat Pour récupérer directement une URL téléchargeable lors de l’interrogation : ```bash curl -X GET "$BASE_URL/v1/video/generations/$TASK_ID" \ -H "Authorization: Bearer $AICENTOS_API_KEY" ``` Réponse type : ```bash { "code": "success", "message": "", "data": { "error": null, "format": "mp4", "metadata": null, "status": "succeeded", "task_id": "task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "url": "https://aicentos.com/v1/videos/task_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx/content" } } ``` ### Télécharger la vidéo Une fois la tâche terminée, téléchargez directement : ```bash curl -L "$BASE_URL/v1/videos/$TASK_ID/content" \ -H "Authorization: Bearer $AICENTOS_API_KEY" \ -o veo-result.mp4 ``` ## Signification des statuts Les statuts renvoyés par `GET /v1/videos/{task_id}` sont principalement : | Statut | Signification | | ------------- | ------------------- | | `queued` | en file d’attente | | `in_progress` | génération en cours | | `completed` | terminée | | `failed` | échec | Les statuts renvoyés par `GET /v1/video/generations/{task_id}` sont principalement : | Statut | Signification | | ------------ | -------------------- | | `queued` | en file d’attente | | `processing` | génération en cours | | `succeeded` | terminée avec succès | | `failed` | échec | ## Points d’attention pour l’intégration * `prompt` est obligatoire. * En image vers vidéo, le champ image doit s’appeler `input_reference`. * Les tâches première/dernière frame exigent les deux frames : première via `input_reference`, dernière via `last_frame` ou `lastFrame`. * Les tâches avec images de référence ne fonctionnent que sur la série Veo 3.1, 3 images maximum, et obligatoirement en 8 secondes. * N’envoyez pas de `negativePrompt` sur les tâches à images de référence. * Pour l’image vers vidéo via Gemini, évitez de passer une URL d’image distante ; préférez un fichier ou du Base64. * Interrogez `GET /v1/videos/{task_id}` par polling et attendez `status=completed` avant de télécharger. * La série Veo 3.1 accepte 4, 6 ou 8 secondes ; 8 secondes sont obligatoires en 1080p ou 4k. - Paysage avec `aspectRatio=16:9`, portrait avec `aspectRatio=9:16` ; sans valeur transmise, 16:9 par défaut. * Ne transmettez pas le paramètre `generateAudio`. La série Veo 3.1 génère nativement l’audio, mais l’API Gemini actuelle ne permet pas de l’activer ou de le désactiver via `generateAudio` ; transmettre ce champ peut renvoyer `INVALID_ARGUMENT` côté amont. * Pour contrôler le contenu audio, décrivez dialogues, sons d’ambiance, effets ou style musical dans le prompt. * Le Veo 3.1 officiel prend en charge l’extension vidéo, mais l’API aicentos actuelle n’expose pas encore l’entrée vidéo officielle.