Configuration de Qwen Code

Couches de configuration

La configuration est appliquée dans l’ordre de priorité suivant (les nombres plus bas sont remplacés par les nombres plus élevés) :

Fichiers de paramètres

Qwen Code utilise des fichiers de paramètres au format JSON pour la configuration persistante. Il existe quatre emplacements possibles pour ces fichiers :

Le répertoire .qwen dans votre projet

En plus d’un fichier de paramètres de projet, le répertoire .qwen d’un projet peut contenir d’autres fichiers spécifiques au projet liés au fonctionnement de Qwen Code, tels que :

• Profils de bac à sable personnalisés (par exemple .qwen/sandbox-macos-custom.sb, .qwen/sandbox.Dockerfile).

Paramètres disponibles dans settings.json

Les paramètres sont organisés par catégories. Tous les paramètres doivent être placés dans leur objet de catégorie de niveau supérieur correspondant dans votre fichier settings.json.

général

output

ui

ide

privacy

model

Exemple model.generationConfig :

{
  "model": {
    "generationConfig": {
      "timeout": 60000,
      "disableCacheControl": false,
      "samplingParams": {
        "temperature": 0.2,
        "top_p": 0.8,
        "max_tokens": 1024
      }
    }
  }
}

Exemples model.openAILoggingDir :

• "~/qwen-logs" - Enregistre les journaux dans le répertoire ~/qwen-logs
• "./custom-logs" - Enregistre les journaux dans ./custom-logs relatif au répertoire courant
• "/tmp/openai-logs" - Enregistre les journaux dans le chemin absolu /tmp/openai-logs

context

Résolution des problèmes de performances de recherche de fichiers

Si vous rencontrez des problèmes de performances avec la recherche de fichiers (par exemple, avec les complétions @), en particulier dans des projets comportant un très grand nombre de fichiers, voici quelques solutions que vous pouvez essayer par ordre de recommandation :

1. Utiliser .qwenignore : Créez un fichier .qwenignore à la racine de votre projet pour exclure les répertoires contenant un grand nombre de fichiers dont vous n’avez pas besoin de référencer (ex. : artefacts de build, journaux, node_modules). Réduire le nombre total de fichiers parcourus est le moyen le plus efficace d’améliorer les performances.
2. Désactiver la recherche floue : Si ignorer des fichiers ne suffit pas, vous pouvez désactiver la recherche floue en définissant disableFuzzySearch sur true dans votre fichier settings.json. Cela utilisera un algorithme de correspondance plus simple et non flou, ce qui peut être plus rapide.
3. Désactiver la recherche récursive de fichiers : En dernier recours, vous pouvez désactiver entièrement la recherche récursive de fichiers en définissant enableRecursiveFileSearch sur false. Il s’agira de l’option la plus rapide puisqu’elle évite un parcours récursif de votre projet. Toutefois, cela signifie que vous devrez taper le chemin complet des fichiers lorsque vous utilisez les complétions @.

outils

mcp

sécurité

advanced

mcpServers

Configure les connexions à un ou plusieurs serveurs Model-Context Protocol (MCP) pour découvrir et utiliser des outils personnalisés. Qwen Code tente de se connecter à chaque serveur MCP configuré afin de découvrir les outils disponibles. Si plusieurs serveurs MCP exposent un outil portant le même nom, les noms des outils seront préfixés avec l’alias du serveur que vous avez défini dans la configuration (par exemple, serverAlias__nomReelDeLOutil) afin d’éviter les conflits. Notez que le système peut supprimer certaines propriétés de schéma des définitions d’outils MCP pour des raisons de compatibilité. Au moins une des propriétés command, url ou httpUrl doit être fournie. Si plusieurs sont spécifiées, l’ordre de priorité est : httpUrl, puis url, puis command.

télémétrie

Configure la collecte de journaux et de métriques pour Qwen Code. Pour plus d’informations, voir télémétrie.

Exemple de settings.json

Voici un exemple de fichier settings.json avec la structure imbriquée, nouvelle depuis la version v0.3.0 :

{
  "general": {
    "vimMode": true,
    "preferredEditor": "code"
  },
  "ui": {
    "theme": "GitHub",
    "hideBanner": true,
    "hideTips": false,
    "customWittyPhrases": [
      "Vous oubliez mille choses chaque jour. Assurez-vous que celle-ci en fait partie",
      "Connexion à l'AGI"
    ]
  },
  "tools": {
    "approvalMode": "yolo",
    "sandbox": "docker",
    "discoveryCommand": "bin/get_tools",
    "callCommand": "bin/call_tool",
    "exclude": ["write_file"]
  },
  "mcpServers": {
    "mainServer": {
      "command": "bin/mcp_server.py"
    },
    "anotherServer": {
      "command": "node",
      "args": ["mcp_server.js", "--verbose"]
    }
  },
  "telemetry": {
    "enabled": true,
    "target": "local",
    "otlpEndpoint": "http://localhost:4317",
    "logPrompts": true
  },
  "privacy": {
    "usageStatisticsEnabled": true
  },
  "model": {
    "name": "qwen3-coder-plus",
    "maxSessionTurns": 10,
    "enableOpenAILogging": false,
    "openAILoggingDir": "~/qwen-logs",
    "summarizeToolOutput": {
      "run_shell_command": {
        "tokenBudget": 100
      }
    }
  },
  "context": {
    "fileName": ["CONTEXT.md", "QWEN.md"],
    "includeDirectories": ["path/to/dir1", "~/path/to/dir2", "../path/to/dir3"],
    "loadFromIncludeDirectories": true,
    "fileFiltering": {
      "respectGitIgnore": false
    }
  },
  "advanced": {
    "excludedEnvVars": ["DEBUG", "DEBUG_MODE", "NODE_ENV"]
  }
}

Historique du Shell

La CLI conserve un historique des commandes shell que vous exécutez. Pour éviter les conflits entre différents projets, cet historique est stocké dans un répertoire spécifique au projet, situé dans le dossier personnel de votre utilisateur.

• Emplacement : ~/.qwen/tmp/<project_hash>/shell_history
  • <project_hash> est un identifiant unique généré à partir du chemin racine de votre projet.
  • L’historique est enregistré dans un fichier nommé shell_history.

Variables d’environnement et fichiers .env

Les variables d’environnement constituent une méthode courante pour configurer des applications, en particulier pour les informations sensibles (comme les jetons) ou les paramètres susceptibles de varier selon les environnements.

Qwen Code peut automatiquement charger les variables d’environnement à partir des fichiers .env. Pour les variables liées à l’authentification (telles que OPENAI_*) et l’approche recommandée avec .qwen/.env, consultez Authentification.

Tableau des variables d’environnement

Arguments de ligne de commande

Les arguments passés directement lors de l’exécution de la CLI peuvent remplacer d’autres configurations pour cette session spécifique.

Tableau des Arguments en Ligne de Commande

Fichiers de contexte (Contexte hiérarchique d’instructions)

Bien qu’ils ne constituent pas strictement une configuration du comportement de l’interface en ligne de commande (CLI), les fichiers de contexte (nommés par défaut QWEN.md, mais configurables via le paramètre context.fileName) sont essentiels pour définir le contexte d’instruction (également appelé « mémoire »). Cette fonctionnalité puissante vous permet de fournir au modèle d’intelligence artificielle des instructions spécifiques au projet, des guides de style de codage ou toute autre information pertinente, rendant ainsi ses réponses plus adaptées et précises selon vos besoins. L’interface inclut des éléments d’interface utilisateur, comme un indicateur dans le pied de page indiquant le nombre de fichiers de contexte chargés, afin de vous informer sur le contexte actif.

• Objectif : Ces fichiers Markdown contiennent des instructions, des directives ou des informations contextuelles que vous souhaitez que le modèle Qwen prenne en compte durant vos interactions. Le système est conçu pour gérer ce contexte d’instruction de manière hiérarchique.

Exemple de Contenu d’un Fichier Contextuel (ex. QWEN.md)

Voici un exemple conceptuel du contenu qu’un fichier contextuel à la racine d’un projet TypeScript pourrait contenir :

# Projet : Ma Superbe Bibliothèque TypeScript

## Instructions Générales :
- Lors de la génération de nouveau code TypeScript, veuillez suivre le style de codage existant.
- Assurez-vous que toutes les nouvelles fonctions et classes possèdent des commentaires JSDoc.
- Privilégiez les paradigmes de programmation fonctionnelle lorsque cela est approprié.
- Tout le code doit être compatible avec TypeScript 5.0 et Node.js 20+.

## Style de Codage :
- Utilisez 2 espaces pour l'indentation.
- Les noms d'interfaces doivent être préfixés par `I` (ex. : `IUserService`).
- Les membres privés des classes doivent être préfixés par un tiret bas (`_`).
- Utilisez toujours l'égalité stricte (`===` et `!==`).

## Composant Spécifique : `src/api/client.ts`
- Ce fichier gère toutes les requêtes API sortantes.
- Lors de l'ajout de nouvelles fonctions d'appel API, assurez-vous qu'elles incluent une gestion d'erreurs et une journalisation robustes.
- Utilisez l'utilitaire `fetchWithRetry` existant pour toutes les requêtes GET.

Concernant les dépendances :

• Évitez d’introduire de nouvelles dépendances externes sauf si cela est absolument nécessaire.
• Si une nouvelle dépendance est requise, veuillez en indiquer la raison.

Cet exemple montre comment vous pouvez fournir un contexte général sur le projet, des conventions de codage spécifiques, ainsi que des notes concernant des fichiers ou composants particuliers. Plus vos fichiers de contexte sont pertinents et précis, mieux l'IA pourra vous assister. L'utilisation de fichiers de contexte spécifiques au projet est fortement encouragée afin d'établir des conventions et un contexte clairs.

- **Chargement hiérarchique et priorité :** L'interface en ligne de commande (CLI) implémente un système de mémoire hiérarchique sophistiqué en chargeant les fichiers de contexte (par exemple, `QWEN.md`) depuis plusieurs emplacements. Le contenu des fichiers situés plus bas dans cette liste (plus spécifiques) remplace généralement ou complète celui des fichiers situés plus haut (plus généraux). L'ordre exact de concaténation et le contexte final peuvent être consultés à l'aide de la commande `/memory show`. L'ordre typique de chargement est le suivant :
  1. **Fichier de contexte global :**
     - Emplacement : `~/.qwen/<nom-du-fichier-de-contexte-configuré>` (par exemple, `~/.qwen/QWEN.md` dans votre répertoire utilisateur).
     - Portée : Fournit des instructions par défaut pour tous vos projets.
  2. **Fichiers de contexte à la racine du projet et dans ses ancêtres :**
     - Emplacement : La CLI recherche le fichier de contexte configuré dans le répertoire de travail actuel, puis dans chaque répertoire parent jusqu'à atteindre soit la racine du projet (identifiée par un dossier `.git`), soit votre répertoire personnel.
     - Portée : Fournit un contexte pertinent pour l'ensemble du projet ou une grande partie de celui-ci.
  3. **Fichiers de contexte dans les sous-répertoires (contextuels/locaux) :**
     - Emplacement : La CLI analyse également la présence du fichier de contexte configuré dans les sous-répertoires _situés sous_ le répertoire de travail actuel (en respectant les motifs d'exclusion courants tels que `node_modules`, `.git`, etc.). Par défaut, cette recherche est limitée à 200 répertoires, mais elle peut être ajustée via le paramètre `context.discoveryMaxDirs` dans votre fichier `settings.json`.
     - Portée : Permet d'inclure des instructions très spécifiques liées à un composant, module ou section particulière de votre projet.
- **Concaténation et indication dans l’interface utilisateur :** Les contenus de tous les fichiers de contexte trouvés sont concaténés (avec des séparateurs indiquant leur origine et leur chemin) et inclus dans l'invite système. Le pied de page de la CLI affiche le nombre total de fichiers de contexte chargés, offrant ainsi un repère visuel rapide sur le contexte instructionnel actif.
- **Importation de contenu :** Vous pouvez modulariser vos fichiers de contexte en important d'autres fichiers Markdown à l’aide de la syntaxe `@chemin/vers/fichier.md`. Pour plus de détails, voir la [documentation du processeur d’importation mémoire](../configuration/memory).
- **Commandes de gestion de la mémoire :**
  - Utilisez `/memory refresh` pour forcer un nouveau scan et recharger tous les fichiers de contexte depuis tous les emplacements configurés. Cela met à jour le contexte instructionnel de l'IA.
  - Utilisez `/memory show` pour afficher le contexte instructionnel combiné actuellement chargé, ce qui vous permet de vérifier la hiérarchie et le contenu utilisé par l'IA.
  - Consultez la [documentation des commandes](../features/commands) pour obtenir tous les détails concernant la commande `/memory` et ses sous-commandes (`show` et `refresh`).

En comprenant et en exploitant ces couches de configuration ainsi que la nature hiérarchique des fichiers de contexte, vous pouvez efficacement gérer la mémoire de l'IA et adapter les réponses de Qwen Code à vos besoins et projets spécifiques.

## Bac à sable

Qwen Code peut exécuter des opérations potentiellement non sûres (comme des commandes shell et des modifications de fichiers) dans un environnement bac à sable pour protéger votre système.

Le [Bac à sable](../features/sandbox) est désactivé par défaut, mais vous pouvez l'activer de plusieurs façons :

- En utilisant le drapeau `--sandbox` ou `-s`.
- En définissant la variable d'environnement `GEMINI_SANDBOX`.
- Le bac à sable est activé par défaut lorsque vous utilisez `--yolo` ou `--approval-mode=yolo`.

Par défaut, il utilise une image Docker pré-construite `qwen-code-sandbox`.

Pour des besoins spécifiques au projet en matière de mise en bac à sable, vous pouvez créer un Dockerfile personnalisé à l'emplacement `.qwen/sandbox.Dockerfile` dans le répertoire racine de votre projet. Ce Dockerfile peut être basé sur l'image de base du bac à sable :

FROM qwen-code-sandbox

Ajoutez vos dépendances ou configurations personnalisées ici

Par exemple :

RUN apt-get update && apt-get install -y some-package

# COPY ./my-config /app/my-config

Lorsque .qwen/sandbox.Dockerfile existe, vous pouvez utiliser la variable d’environnement BUILD_SANDBOX lors de l’exécution de Qwen Code pour construire automatiquement l’image sandbox personnalisée :

BUILD_SANDBOX=1 qwen -s

Statistiques d’utilisation

Pour nous aider à améliorer Qwen Code, nous collectons des statistiques d’utilisation anonymisées. Ces données nous aident à comprendre comment l’interface en ligne de commande (CLI) est utilisée, à identifier les problèmes courants et à prioriser les nouvelles fonctionnalités.

Ce que nous collectons :

• Appels d’outils : Nous enregistrons les noms des outils appelés, qu’ils réussissent ou échouent, ainsi que le temps nécessaire à leur exécution. Nous ne collectons pas les arguments transmis aux outils ni les données renvoyées par ceux-ci.
• Requêtes API : Nous enregistrons le modèle utilisé pour chaque requête, la durée de celle-ci et son succès ou échec. Nous ne collectons pas le contenu des invites ou des réponses.
• Informations sur la session : Nous collectons des informations concernant la configuration de l’interface CLI, telles que les outils activés et le mode d’approbation.

Ce que nous ne collectons PAS :

• Informations personnelles identifiables (PII) : Nous ne collectons aucune information personnelle telle que votre nom, votre adresse e-mail ou vos clés API.
• Contenu des invites et des réponses : Nous n’enregistrons pas le contenu de vos invites ou des réponses du modèle.
• Contenu des fichiers : Nous n’enregistrons pas le contenu des fichiers lus ou écrits par l’interface CLI.

Comment désactiver cette collecte :

Vous pouvez à tout moment désactiver la collecte des statistiques d’utilisation en définissant la propriété usageStatisticsEnabled sur false dans la catégorie privacy de votre fichier settings.json :

{
  "privacy": {
    "usageStatisticsEnabled": false
  }
}