Mise à jour de la documentation : Cet ancien aperçu d'une seule page a été déplacé. Découvrez notre nouvelle documentation et nos guides multipages.
Aller à l'accueil de la documentation →

Démarrage rapide pour XMemo

Utilisez XMemo comme espace centralisé de mémoire partagée pour assistants IA : connectez un client, sauvegardez le contexte utile une seule fois, rappelez-le ultérieurement et gardez vos identifiants hors de toute configuration publique.

Introduction #

Utilisez XMemo comme espace centralisé de mémoire partagée pour assistants IA : connectez un client, sauvegardez le contexte utile une seule fois, rappelez-le ultérieurement et gardez vos identifiants hors de toute configuration publique.

Un espace de mémoire unique

Conservez les préférences durables, les faits de projets, les décisions et les notes de passation dans une couche de mémoire appartenant à l'utilisateur, que les assistants autorisés peuvent rappeler.

Connectez votre client

Utilisez l'URL MCP hébergée avec le profil client pour ChatGPT, Claude, VS Code / GitHub Copilot, Copilot CLI, Codex, Gemini, Cursor ou des exécuteurs MCP directs.

Gardez le contrôle

Utilisez OAuth lorsqu'il est pris en charge, la transmission de secrets par variables d'environnement pour les clients directs, et les contrôles de compte pour la révision, la suppression et les périmètres d'exportation.

Persona onboarding flows #

Utilisateur de ChatGPT

Goal
Donnez à ChatGPT un accès durable à vos préférences XMemo, faits de projet, décisions et TODOs sans coller de jetons bearer dans un chat.
Connection
Connectez le serveur MCP XMemo hébergé via le flux OAuth de l'application ChatGPT/OpenAI, puis approuvez les autorisations memory:read et memory:write pour votre compte XMemo.
Success action
Enregistrez une préférence synthétique ou une note de projet, démarrez un nouveau chat, puis demandez à ChatGPT de la rappeler via XMemo avant de poursuivre le travail.
Troubleshooting
Si OAuth échoue ou si les outils n'apparaissent pas, déconnectez-vous du serveur MCP dans l'application hôte, reconnectez l'URL du serveur XMemo et réessayez avant de créer des jetons directs.

Développeur Copilot / Codex

Goal
Transmettez les décisions du dépôt, les conventions de codage, les notes de correctifs et l'historique des tâches entre les agents IDE et CLI.
Connection
Utilisez OAuth pour VS Code / GitHub Copilot et Gemini CLI lorsqu'il est disponible. Pour Copilot CLI, Codex, Cursor ou d'autres clients MCP directs, conservez XMEMO_KEY dans l'environnement local ou le gestionnaire de secrets et définissez un identifiant XMEMO_AGENT_INSTANCE_ID stable.
Success action
Enregistrez une décision relative au code ou un correctif, puis demandez au prochain agent de l'IDE ou de la CLI de rappeler le contexte XMemo pertinent avant toute modification.
Troubleshooting
Si les rappels sont vides, vérifiez le chemin de configuration MCP sélectionné, la variable d'environnement XMEMO_KEY pour les clients directs et tout identifiant OAuth obsolète dans l'application hôte.

Responsable de projet pilote d'équipe / entreprise

Goal
Évaluez la mémoire partagée avec les contrôles de compte, l'attribution des sources, les flux d'exportation/suppression et des preuves de configuration sécurisées pour les évaluateurs.
Connection
Créez ou rejoignez l'espace de travail sécurisé XMemo, invitez les utilisateurs approuvés, puis connectez chaque client via OAuth ou un identifiant direct délimité selon les badges de disponibilité.
Success action
Demandez à un membre du projet pilote d'enregistrer une mémoire d'équipe synthétique, confirmez l'attribution de la source dans XMemo, puis examinez les chemins de suppression/exportation et de support.
Troubleshooting
Si un membre ne parvient pas à se connecter, vérifiez les permissions de rôle, l'approbation OAuth, l'état de disponibilité du client et les conseils du support avant d'émettre un nouveau jeton.

Opérateur d'agents autonomes

Goal
Permettez aux agents autonomes ou planifiés d'enregistrer leur progression, de récupérer les décisions antérieures et de conserver une identité d'instance stable et non secrète.
Connection
Récupérez /api/v1/mcp/config/autonomous-agent. Privilégiez auth_modes.oauth lorsque l'exécuteur prend en charge OAuth + en-têtes personnalisés ; utilisez auth_modes.xmemo_key avec XMEMO_KEY issu d'un gestionnaire de secrets uniquement pour les exécuteurs entièrement autonomes.
Success action
Exécutez une tâche synthétique qui consigne la progression dans XMemo, redémarrez l'exécuteur et confirmez qu'il rappelle cette progression à l'aide du même XMEMO_AGENT_INSTANCE_ID.
Troubleshooting
Si l'attribution change ou si les rappels se scindent entre instances, conservez XMEMO_AGENT_INSTANCE_ID hors de git et vérifiez que l'exécuteur ne le régénère pas à chaque démarrage.

Contrôles de la console de mémoire #

XMemo n'est pas seulement un point de terminaison MCP. La Memory Console est l'espace utilisateur pour examiner, corriger, supprimer et exporter la mémoire tout en gardant l'attribution des agents visible.

Consulter et rechercher dans la mémoire

Ouvrez la console pour consulter les mémoires enregistrées, examiner les chemins et types de mémoire, et confirmer si un rappel aurait dû renvoyer un élément particulier.

Modifier ou corriger des entrées

Corrigez les informations obsolètes, déplacez les éléments vers des chemins plus clairs ou remplacez les notes dépassées afin que les futurs assistants rappellent le contexte le plus récent validé par l'utilisateur.

Supprimer et exporter

Utilisez les parcours du compte pour supprimer les mémoires dont vous ne voulez plus et repérer les chemins d'exportation pour l'examen de la mémoire au niveau du compte.

Attribution des agents

Examinez quel client ou exécuteur a créé une mémoire, y compris les étiquettes non secrètes d'agent et d'instance lorsque le client les transmet.

Contrôles de confidentialité et d'identifiants

Maintenez visibles le consentement OAuth, l'utilisation de jetons directs, la transmission de secrets par environnement et les limites de support avant d'étendre un projet pilote personnel ou d'équipe.

Demander l'accès à XMemo #

Point d'entrée de compte ouvert ↗

Démarrage rapide avec XMemo hébergé #

Commencez avec le service XMemo infogéré et l'un de ces modes de connexion. Les configurations auto-hébergées, Docker, Supabase et paquets Python sont des références pour développeurs, et non le premier parcours destiné aux utilisateurs du service hébergé.

Demander à votre agent

Collez cette instruction dans un agent de confiance pour qu'il suive ses vérifications habituelles de sécurité.

Installez le Skill XMemo autonome dans votre répertoire de skills : exécutez le programme d'installation depuis https://xmemo.dev/skill/install (sous Windows, https://xmemo.dev/skill/install.ps1) avec XMEMO_SKILL_DIR défini sur votre répertoire de skills plus /xmemo-memory. Exécutez la commande doctor affichée pour vérifier l'installation, puis rechargez vos skills et suivez les étapes de premier lancement du Skill. Respectez vos contrôles de sécurité habituels et n'utilisez pas de privilèges élevés.

Clients OAuth

Utilisez ce mode pour ChatGPT, l'évaluation d'application OpenAI, VS Code et GitHub Copilot lorsque l'hôte prend en charge OAuth. Ajoutez l'URL MCP hébergée, approuvez memory:read et memory:write, et ne collez pas XMEMO_KEY dans la configuration du client.

MCP URL: https://xmemo.dev/mcp
Scopes: memory:read memory:write

MCP direct avec XMEMO_KEY

N'utilisez cette méthode que pour les clients ou exécuteurs sans interface ne pouvant pas effectuer le flux OAuth. Enregistrez XMEMO_KEY dans l'environnement local ou le gestionnaire de secrets, conservez l'URL MCP hébergée dans la configuration et ne collez jamais le véritable jeton dans des documents publics ou un chat.

MCP URL: https://xmemo.dev/mcp
Token source: XMEMO_KEY environment variable
Optional identity: XMEMO_AGENT_INSTANCE_ID

Contrôles du compte

Après la première connexion, utilisez l'accès au compte pour examiner ce qui a été enregistré, vérifier l'attribution des agents et localiser les chemins de suppression/exportation ou de support avant d'étendre un projet pilote.

Account entry: https://xmemo.dev/login

Sécurité publique #

  • La découverte publique est en lecture seule et sans secret.
  • Client setup requires secrets in environment variables or a system secret store, not in generated URLs.
  • La documentation produit publique évite délibérément tout lien vers les consoles d'opérateur, la documentation de l'API, le JSON de découverte, les catalogues d'installateurs, les URL de bootstrap brutes, les URL de service brutes et les éléments d'authentification.

Preuve de source #

Documentation basée sur les sources issue de la route de découverte XMemo, du contrat de découverte hébergé, du serveur MCP et du SDK TypeScript.

FAQ / Dépannage #

  • Pourquoi mon assistant IA ne se souvient-il pas de ce que je lui ai dit plus tôt ? —
  • Pourquoi mon assistant IA mélange-t-il mes projets ou mes conversations ? —
  • Comment puis-je faire oublier complètement quelque chose à mon assistant IA ? —
  • J'ai changé d'ordinateur ou d'assistant IA ; XMemo se souviendra-t-il toujours de moi ? —
  • Pourquoi mon assistant IA a-t-il enregistré la même chose deux fois ? —
  • Pourquoi mon assistant IA me donne-t-il trop ou pas assez de mon contexte passé ? —
  • J'ai déconnecté XMemo ; comment m'assurer que l'ancien assistant ne peut plus l'utiliser ? —
  • Pourquoi mon assistant IA ne peut-il plus utiliser XMemo ? —
  • Quelle connexion XMemo dois-je utiliser dans mon assistant IA ? —
  • Que dois-je faire si mon assistant IA ne parvient toujours pas à se connecter à XMemo ? —

Prérequis #

  • Approved service URL - Used by xmemo setup --url to fetch discovery, onboarding status, and MCP config templates.
  • Node.js and npm - Discovery and the product page advertise @xmemo/client as the public CLI package.
  • Scoped token or OAuth grant - ChatGPT and VS Code / GitHub Copilot use OAuth; direct MCP and REST clients use XMEMO_KEY from an environment variable or secret store.

Se connecter avec XMemo #

xmemo setup --url drives the entire trial. The documented hosted setup flow is implemented as discovery → onboarding status → MCP config template → reviewed client configuration.

npm install -g @xmemo/client
npx @xmemo/client setup --url https://xmemo.dev

Configuration MCP #

XMemo MCP setup lives in Docs because auth differs by client. ChatGPT, VS Code / GitHub Copilot, and Gemini CLI use hosted OAuth; direct/headless clients use the hosted Streamable HTTP URL plus XMEMO_KEY from the local environment or secret store.

VS Code / GitHub Copilot

%APPDATA%\Code\User\mcp.json

{
  "servers": {
    "XMemo": {
      "type": "http",
      "url": "https://xmemo.dev/mcp"
    }
  }
}

Cursor

~/.cursor/mcp.json

{
  "mcpServers": {
    "XMemo": {
      "url": "https://xmemo.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${env:XMEMO_KEY}",
        "X-Memory-OS-Agent-ID": "cursor",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Codex

~/.codex/config.toml

[mcp_servers.XMemo]
url = "https://xmemo.dev/mcp"
bearer_token_env_var = "XMEMO_KEY"

[mcp_servers.XMemo.http_headers]
X-Memory-OS-Agent-ID = "codex"

[mcp_servers.XMemo.env_http_headers]
X-Memory-OS-Agent-Instance-ID = "XMEMO_AGENT_INSTANCE_ID"

Gemini CLI

~/.gemini/settings.json

{
  "mcpServers": {
    "XMemo": {
      "httpUrl": "https://xmemo.dev/mcp",
      "headers": {
        "X-Memory-OS-Agent-ID": "gemini-cli",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Claude Desktop

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "XMemo": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://xmemo.dev/mcp",
        "--header",
        "Authorization:Bearer ${XMEMO_KEY}",
        "--header",
        "X-Memory-OS-Agent-ID:claude-desktop",
        "--header",
        "X-Memory-OS-Agent-Instance-ID:${XMEMO_AGENT_INSTANCE_ID}"
      ],
      "env": {
        "XMEMO_AGENT_INSTANCE_ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Devin Desktop (formerly Windsurf)

~/.config/devin/mcp_config.json

{
  "mcpServers": {
    "XMemo": {
      "serverUrl": "https://xmemo.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${env:XMEMO_KEY}",
        "X-Memory-OS-Agent-ID": "windsurf",
        "X-Memory-OS-Agent-Instance-ID": "${env:XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Kiro

~/.kiro/settings/mcp.json

{
  "mcpServers": {
    "XMemo": {
      "url": "https://xmemo.dev/mcp",
      "headers": {
        "X-Memory-OS-Agent-ID": "kiro",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      },
      "oauth": {
        "oauthScopes": [
          "memory:read",
          "knowledge:read"
        ]
      }
    }
  }
}

Muse Code

~/.config/muse/settings.json

{"schema_version": 1, "mcpServers": {"xmemo": {"type": "streamable-http", "url": "https://xmemo.dev/mcp", "mode": "optional"}}}

OpenClaw

~/.openclaw/openclaw.json

{
  "mcpServers": {
    "XMemo": {
      "url": "https://xmemo.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${env:XMEMO_KEY}",
        "X-Memory-OS-Agent-ID": "openclaw",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Copilot CLI

~/.copilot/mcp-config.json

{
  "mcpServers": {
    "XMemo": {
      "type": "http",
      "url": "http://127.0.0.1:8765/mcp"
    }
  }
}

ChatGPT / OpenAI Apps SDK

Tableau de bord de gestion d'applications OpenAI Platform

{
  "mcpServers": {
    "XMemo": {
      "url": "https://xmemo.dev/mcp",
      "transport": "streamable-http",
      "auth": {
        "type": "oauth2",
        "resource": "https://xmemo.dev/mcp",
        "scopes": ["memory:read", "memory:write"]
      }
    }
  }
}

Autonomous agent

Configuration MCP pour l'exécuteur d'agent

{
  "mcpServers": {
    "XMemo": {
      "type": "http",
      "transport": "streamable-http",
      "url": "https://xmemo.dev/mcp",
      "headers": {
        "X-Memory-OS-Agent-ID": "autonomous-agent",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      },
      "auth": {
        "type": "oauth2",
        "flow": "authorization_code",
        "pkce_required": true,
        "resource": "https://xmemo.dev/mcp",
        "scopes": ["memory:read", "memory:write"]
      },
      "fallback": {
        "use_when": "headless runner cannot complete OAuth sign-in or persist OAuth tokens",
        "authorization_header": "Bearer ${XMEMO_KEY}"
      }
    }
  }
}

Autre

Tout agent compatible MCP

{
  "mcpServers": {
    "XMemo": {
      "transport": "streamable-http",
      "url": "https://xmemo.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${XMEMO_KEY}",
        "X-Memory-OS-Agent-ID": "${XMEMO_AGENT_ID}",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Kimi Code

~/.kimi-code/mcp.json

{
  "mcpServers": {
    "XMemo": {
      "url": "https://xmemo.dev/mcp",
      "bearerTokenEnvVar": "XMEMO_KEY",
      "headers": {
        "X-Memory-OS-Agent-ID": "kimi-code",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Claude Code

~/.claude.json

{
  "mcpServers": {
    "XMemo": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://xmemo.dev/mcp",
        "--header",
        "Authorization:Bearer ${XMEMO_KEY}",
        "--header",
        "X-Memory-OS-Agent-ID:claude-code",
        "--header",
        "X-Memory-OS-Agent-Instance-ID:${XMEMO_AGENT_INSTANCE_ID}"
      ],
      "env": {
        "XMEMO_AGENT_INSTANCE_ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Claude Desktop

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "XMemo": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://xmemo.dev/mcp",
        "--header",
        "Authorization:Bearer ${XMEMO_KEY}",
        "--header",
        "X-Memory-OS-Agent-ID:claude-desktop",
        "--header",
        "X-Memory-OS-Agent-Instance-ID:${XMEMO_AGENT_INSTANCE_ID}"
      ],
      "env": {
        "XMEMO_AGENT_INSTANCE_ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Cline (VS Code)

~/Documents/Cline/MCP/cline_mcp_settings.json

{
  "mcpServers": {
    "XMemo": {
      "httpUrl": "https://xmemo.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${env:XMEMO_KEY}",
        "X-Memory-OS-Agent-ID": "cline",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Continue (VS Code / JetBrains)

~/.continue/config.json

{
  "mcpServers": {
    "XMemo": {
      "transport": {
        "type": "streamable-http",
        "url": "https://xmemo.dev/mcp",
        "headers": {
          "Authorization": "Bearer ${XMEMO_KEY}",
          "X-Memory-OS-Agent-ID": "continue",
          "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
        }
      }
    }
  }
}

Zed

Zed settings.json (varies by OS)

{
  "context_servers": {
    "XMemo": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://xmemo.dev/mcp",
        "--header",
        "Authorization:Bearer ${XMEMO_KEY}",
        "--header",
        "X-Memory-OS-Agent-ID:zed",
        "--header",
        "X-Memory-OS-Agent-Instance-ID:${XMEMO_AGENT_INSTANCE_ID}"
      ],
      "env": {
        "XMEMO_AGENT_INSTANCE_ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Trae

Trae user config mcp.json (varies by OS)

{
  "mcpServers": {
    "XMemo": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://xmemo.dev/mcp",
        "--header",
        "Authorization:Bearer ${XMEMO_KEY}",
        "--header",
        "X-Memory-OS-Agent-ID:trae",
        "--header",
        "X-Memory-OS-Agent-Instance-ID:${XMEMO_AGENT_INSTANCE_ID}"
      ],
      "env": {
        "XMEMO_AGENT_INSTANCE_ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Grok

~/.grok/config.toml

{
  "mcpServers": {
    "XMemo": {
      "type": "http",
      "url": "https://xmemo.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${XMEMO_KEY}",
        "X-Memory-OS-Agent-ID": "grok",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Antigravity 2.0

~/.gemini/config/mcp_config.json

{
  "mcpServers": {
    "XMemo": {
      "serverUrl": "https://xmemo.dev/mcp",
      "headers": {
        "X-Memory-OS-Agent-ID": "antigravity",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Qwen

~/.qwen/settings.json

{
  "mcpServers": {
    "XMemo": {
      "httpUrl": "https://xmemo.dev/mcp",
      "headers": {
        "X-Memory-OS-Agent-ID": "qwen",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

OpenCode

~/.config/opencode/opencode.json

{
  "mcp": {
    "XMemo": {
      "type": "remote",
      "url": "https://xmemo.dev/mcp",
      "enabled": true,
      "headers": {
        "X-Memory-OS-Agent-ID": "opencode",
        "X-Memory-OS-Agent-Instance-ID": "${XMEMO_AGENT_INSTANCE_ID}"
      }
    }
  }
}

Matrice de fonctionnalités client #

The canonical matrix is the source of truth for each client's OAuth mode, MCP transport, credential handling, readiness, evidence boundary, and marketplace state. This page only provides the setup console; do not copy a status into another page without checking the matrix.

Read CLIENT_CAPABILITY_MATRIX.md on GitHub ↗

Préréglage pour agent autonome #

Autonomous agents should fetch /api/v1/mcp/config/autonomous-agent instead of asking humans to choose identity fields.

Surface d'outils MCP #

The discovery response lists the actual MCP transport as streamable-http and advertises tools implemented by the XMemo MCP server.

  • Recall tools - search_memory, recall, recall_plan, and recall_context.
  • Write tools - remember, store_memory, update_memory, and record_event.
  • Governance tools - forget_memory, redact_memory, explain_memory, and conflict/version helpers.

Assistants de flux de travail SDK #

The TypeScript SDK exposes workflow helpers in packages/memory-os-js. These helpers route events through capture policy before writing memory.

Compétences et agents #

Skills are the instruction-and-command lane for agents that do not mount a hosted MCP server directly.

Étapes suivantes #