install
Start with your tool's Marketplace when Vertiso Memory is published
there. Until then, install the complete plugin from Vertiso's public
GitHub repository when your tool supports it, or connect directly to
our remote
Model Context Protocol
server with browser OAuth. Prefer the terminal, need a local bridge,
or want to script your memory? The
vmem
CLI is further down.
Each panel shows the best available route in order: a live
Marketplace listing, the public Vertiso plugin repository, native
HTTP MCP, then the local
vmem
bridge. Unpublished Marketplace links stay hidden until they work.
https://memory.vertiso.ai/mcp
Pin your user card for the best experience.
Once Vertiso Memory has synthesized a knowledge card about you
(automatic — happens after you've saved a few memories), pin
vertiso-memory://knowledge/user/self
in your client's resource picker. It's the single best piece
of ambient context — your preferences, working style,
recurring constraints — distilled and kept current
automatically.
A page for each tool: Claude Claude Desktop Claude Code Cursor Codex ChatGPT VS Code JetBrains Raycast Antigravity
A page for each tool: Claude Claude Desktop Claude Code
Install Vertiso Memory from its public GitHub marketplace for the complete experience in Claude.ai web chat, Claude Desktop Chat, and Cowork. It adds the remote MCP server plus checkpoint, handoff, handoff-resume, and wrap-up skills.
Customize → Plugins → Personal plugins → + → Add marketplace
Choose Add from a repository
Repository: https://github.com/Vertiso/memory-claude
Sync, open Vertiso Memory, then select Install
Add the marketplace once, install Vertiso Memory, then start a new conversation. Source and release notes: Vertiso/memory-claude. Mobile currently uses the MCP-only connector below.
Generate a bearer token if you prefer token authentication for Claude web or mobile.
MCP-only alternative. In Claude.ai, open Customize in the left sidebar → Connectors → + → Add custom connector . Enter the name and URL, leave the authentication fields blank, and click Add. Claude discovers Vertiso Memory's OAuth server, sends you here to sign in and approve access, and finishes the handshake — nothing to paste.
Name: Vertiso Memory
URL: https://memory.vertiso.ai/mcp
Put the bearer token generated above in the connector's auth field. OAuth is the recommended path for web clients — the handshake scopes access and you can revoke it independently — but the bearer path remains fully supported.
Name: Vertiso Memory
URL: https://memory.vertiso.ai/mcp
Auth: Bearer <paste your token here>
After Claude.ai completes the handshake, the
vertiso-memory tools and resources show
up under
+
→
Connectors
in a conversation. The
account-level connector is also available in Claude Desktop, Cowork, and
mobile. Pin
vertiso-memory://knowledge/user/self
to keep your user card as ambient context.
Recommended: add a bootstrap instruction to Claude.ai's custom instructions (Settings, Personalization) so your assistant registers with Vertiso Memory at the start of every session:
Vertiso Memory (vmem) is my persistent memory across every tool and session.
- Call the `hello` tool at the start of every session. Treat its primer
as authoritative context, not a suggestion.
- `recall` before planning or answering anything that may depend on
earlier context. Look it up instead of asking me to repeat it.
- `remember` durable decisions, preferences, constraints, and project
state the moment they land. `update_memory` rather than writing a
near-duplicate.
- Offer a handoff before the session ends, compacts, or moves to
another tool.
Claude Desktop is the unified app for Chat , Cowork , and Code . The shared plugin above works in Chat and Cowork. In the Code tab, select + → Plugins → Add plugin , then select Vertiso Memory from the configured marketplace.
MCP-only alternative. If you already connected Vertiso Memory on Claude.ai, the account-level connector is available in Claude Desktop too. Otherwise, open Customize → Connectors → + → Add custom connector . Enter the name and URL, leave the advanced OAuth fields blank, and click Add. Claude discovers Vertiso Memory's OAuth server, sends you here to sign in and approve, and finishes the handshake — nothing to paste.
Name: Vertiso Memory
URL: https://memory.vertiso.ai/mcp
vmem
bridge instead.
The
vmem
CLI bridges Claude Desktop's local stdio MCP to the HTTP endpoint
and keeps your bearer token in
~/.vmem
rather than the config file. Run
vmem mcp install claude-desktop
to write the entry automatically, then fully restart Claude
Desktop.
{
"mcpServers": {
"vertiso-memory": {
"command": "<run `which vmem` to get the absolute path>",
"args": ["mcp", "serve", "--client", "claude-desktop"]
}
}
}
Without
vmem,
the Node-based
mcp-remote
bridge works too, but the bearer token then lives in the config
file.
{
"mcpServers": {
"vertiso-memory": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://memory.vertiso.ai/mcp",
"--header",
"Authorization: Bearer <paste your token here>",
"--header",
"X-Agent-Source: agent:claude-desktop"
]
}
}
}
The connector and local bridge expose MCP tools only; use the GitHub plugin
above for the bundled skills. After connecting, pin
vertiso-memory://knowledge/user/self
to keep your user card as ambient context.
Recommended: add a bootstrap instruction to your Claude account's custom instructions (Settings, Personalization) so your assistant registers with Vertiso Memory at the start of every session:
Vertiso Memory (vmem) is my persistent memory across every tool and session.
- Call the `hello` tool at the start of every session. Treat its primer
as authoritative context, not a suggestion.
- `recall` before planning or answering anything that may depend on
earlier context. Look it up instead of asking me to repeat it.
- `remember` durable decisions, preferences, constraints, and project
state the moment they land. `update_memory` rather than writing a
near-duplicate.
- Offer a handoff before the session ends, compacts, or moves to
another tool.
This section is for the terminal CLI, which is installed separately from Claude Desktop. Install the complete plugin from Vertiso's public GitHub repository. It adds the remote MCP server and all four session skills.
/plugin marketplace add Vertiso/memory-claude
/plugin install vertiso-memory@vertiso
Start a new Claude Code CLI session after installation so the plugin and its skills are loaded.
Source and release notes: Vertiso/memory-claude .
MCP-only alternative.
Add Vertiso Memory as a remote HTTP server, then run
/mcp
and choose
Authenticate
. Claude Code
CLI opens your browser, completes OAuth, and refreshes the token
automatically.
claude mcp add --transport http vertiso-memory https://memory.vertiso.ai/mcp
# then run /mcp in Claude Code CLI and choose Authenticate
Direct HTTP also accepts a bearer token, but stores that token in
~/.claude.json
or the project
.mcp.json
.
claude mcp add vertiso-memory \
--transport http https://memory.vertiso.ai/mcp \
--header 'Authorization: Bearer <paste your token here>' \
--header 'X-Agent-Source: agent:claude-code'
{
"mcpServers": {
"vertiso-memory": {
"type": "http",
"url": "https://memory.vertiso.ai/mcp",
"headers": {
"Authorization": "Bearer <paste your token here>",
"X-Agent-Source": "agent:claude-code"
}
}
}
}
For a local, headless bridge, run
vmem mcp install claude-code
.
The bridge keeps its token in
~/.vmem
and writes the user-scoped Claude configuration automatically.
{
"mcpServers": {
"vertiso-memory": {
"command": "<run `which vmem` to get the absolute path>",
"args": ["mcp", "serve", "--client", "claude-code"]
}
}
}
For project-scoped fallback config, add
.mcp.json
to .gitignore
before pasting a real token.
Recommended: add a bootstrap instruction to your CLAUDE.md or AGENTS.md so your assistant registers with Vertiso Memory at the start of every session:
Vertiso Memory (vmem) is my persistent memory across every tool and session.
- Call the `hello` tool at the start of every session. Treat its primer
as authoritative context, not a suggestion.
- `recall` before planning or answering anything that may depend on
earlier context. Look it up instead of asking me to repeat it.
- `remember` durable decisions, preferences, constraints, and project
state the moment they land. `update_memory` rather than writing a
near-duplicate.
- Offer a handoff before the session ends, compacts, or moves to
another tool.
A page for each tool: ChatGPT Codex
OpenAI now provides local Codex work through the ChatGPT desktop app, alongside Codex CLI and the Codex IDE extension. Choose the path for the surface you use.
Until Vertiso Memory appears in OpenAI's Plugins Directory, install the complete plugin from its public GitHub repository. It adds the remote MCP server plus checkpoint, handoff, handoff-resume, and wrap-up skills.
codex plugin marketplace add Vertiso/memory-codex
codex plugin add vertiso-memory@vertiso-memory-codex
The CLI command installs the plugin for Codex CLI. For the ChatGPT desktop app, restart it, choose Work mode or Codex, open Plugins, select the Vertiso marketplace, and install Vertiso Memory if it is not already shown under Installed. Source and release notes: Vertiso/memory-codex. Full plugins are not available in the Codex IDE extension; use the shared MCP setup below instead. When the directory listing becomes public, switch to that installation so OpenAI manages future updates.
Set up the connection once on ChatGPT web. Open Settings → Security and login, enable Developer mode, then open Settings → Plugins, select +, and create a developer-mode MCP app.
Name: Vertiso Memory
URL: https://memory.vertiso.ai/mcp
Auth: OAuth
Complete the browser sign-in. This path exposes Vertiso Memory's MCP tools, not the four bundled skills. After setup on web, this MCP app was verified in the current ChatGPT iOS app. If it does not appear there, refresh or reconnect it from ChatGPT web. Developer-mode app availability can depend on your plan and workspace policy.
These local Codex clients share the same MCP configuration. In the ChatGPT desktop app, open Settings → MCP servers → Add server, choose Streamable HTTP, enter the name and URL, save, restart, then select Authenticate.
Name: Vertiso Memory
URL: https://memory.vertiso.ai/mcp
The ChatGPT desktop app, Codex CLI, and Codex IDE extension share ~/.codex/config.toml. To configure it from the CLI, add the server and sign in:
# ~/.codex/config.toml
[mcp_servers.vertiso-memory]
url = "https://memory.vertiso.ai/mcp"
# then: codex mcp login vertiso-memory
In the Codex IDE extension, open the gear menu → MCP servers → Add server, enter the name and URL, choose Streamable HTTP, save, restart the extension, then select Authenticate.
Without browser OAuth, the Node-based mcp-remote bridge stores the bearer token in the shared Codex configuration:
[mcp_servers.vertiso-memory]
command = "npx"
args = [
"-y",
"mcp-remote",
"https://memory.vertiso.ai/mcp",
"--header",
"Authorization: Bearer <paste your token here>",
"--header",
"X-Agent-Source: agent:codex",
]
For a local bridge that keeps the token in ~/.vmem, run vmem mcp install codex. Restart any open ChatGPT desktop, Codex CLI, and Codex IDE extension sessions afterward.
[mcp_servers.vertiso-memory]
command = "<run `which vmem` to get the absolute path>"
args = ["mcp", "serve", "--client", "codex"]
Recommended: add a bootstrap instruction to ChatGPT custom instructions or your AGENTS.md for local Codex work so your assistant registers with Vertiso Memory at the start of every session:
Vertiso Memory (vmem) is my persistent memory across every tool and session.
- Call the `hello` tool at the start of every session. Treat its primer
as authoritative context, not a suggestion.
- `recall` before planning or answering anything that may depend on
earlier context. Look it up instead of asking me to repeat it.
- `remember` durable decisions, preferences, constraints, and project
state the moment they land. `update_memory` rather than writing a
near-duplicate.
- Offer a handoff before the session ends, compacts, or moves to
another tool.
A page for each tool: Cursor
For the complete plugin with all four session skills, clone Vertiso's public GitHub repository and copy it into Cursor's local plugin directory.
git clone https://github.com/Vertiso/memory-cursor.git
mkdir -p ~/.cursor/plugins/local
cp -R memory-cursor/vertiso-memory ~/.cursor/plugins/local/vertiso-memory
# Restart Cursor or run "Developer: Reload Window"
Use a physical copy. Cursor rejects a symlink whose target is outside its local plugin directory. Source and release notes: Vertiso/memory-cursor .
MCP-only alternative. Click Add MCP server to Cursor , or open Settings → Tools & MCP → New MCP Server . Cursor opens your browser for OAuth. This connects memory tools without the bundled skills.
Add MCP server to Cursor MCP only — bundled skills not included
Name: Vertiso Memory
URL: https://memory.vertiso.ai/mcp
Direct HTTP also accepts a bearer token stored in
~/.cursor/mcp.json
or the project's
.cursor/mcp.json
:
{
"mcpServers": {
"vertiso-memory": {
"type": "http",
"url": "https://memory.vertiso.ai/mcp",
"headers": {
"Authorization": "Bearer <paste your token here>",
"X-Agent-Source": "agent:cursor"
}
}
}
}
For a local bridge that keeps its token in
~/.vmem
, run
vmem mcp install cursor
.
It writes the user-scoped MCP configuration automatically.
{
"mcpServers": {
"vertiso-memory": {
"command": "<run `which vmem` to get the absolute path>",
"args": ["mcp", "serve", "--client", "cursor"]
}
}
}
Recent Cursor builds support the OAuth connect flow directly; older builds can fall back to the vmem bridge or direct HTTP.
Restart Cursor's Composer (or run
MCP: Reload servers
from the command palette) to pick up the new server.
Recommended: add a bootstrap instruction to your Cursor Rules (a User Rule or a project rule) so your assistant registers with Vertiso Memory at the start of every session:
Vertiso Memory (vmem) is my persistent memory across every tool and session.
- Call the `hello` tool at the start of every session. Treat its primer
as authoritative context, not a suggestion.
- `recall` before planning or answering anything that may depend on
earlier context. Look it up instead of asking me to repeat it.
- `remember` durable decisions, preferences, constraints, and project
state the moment they land. `update_memory` rather than writing a
near-duplicate.
- Offer a handoff before the session ends, compacts, or moves to
another tool.
A page for each tool: VS Code
The complete extension is available from Vertiso's public GitHub repository while its Marketplace listing is not yet live. A local build adds the remote MCP server and all four Agent Skills. After publication, uninstall the local 1.0.0 build before installing from the Marketplace so it owns future updates.
# Build-only requirements: Node.js 24 and npm
git clone https://github.com/Vertiso/memory-vscode.git
cd memory-vscode
npm ci
npm run package
# Run "Extensions: Install from VSIX..." and select:
# build/vertiso-memory-vscode.vsix
MCP-only alternative.
In VS Code, run
MCP: Add Server
→
HTTP
, paste the URL, and
confirm. VS Code opens your browser for OAuth. You can also put the config
below in
.vscode/mcp.json
or your user
mcp.json
.
{
"servers": {
"vertiso-memory": {
"type": "http",
"url": "https://memory.vertiso.ai/mcp"
}
}
}
Direct HTTP also accepts a bearer token stored in the MCP config:
{
"servers": {
"vertiso-memory": {
"type": "http",
"url": "https://memory.vertiso.ai/mcp",
"headers": {
"Authorization": "Bearer <paste your token here>",
"X-Agent-Source": "agent:vscode"
}
}
}
}
For a CLI-managed local bridge, skills, and SessionStart primer, run
vmem mcp install vscode
.
The bridge keeps its token in
~/.vmem
.
It also covers the github.com Copilot coding agent, which cannot use
remote OAuth servers.
{
"servers": {
"vertiso-memory": {
"command": "<run `which vmem` to get the absolute path>",
"args": ["mcp", "serve", "--client", "vscode"]
}
}
}
Use only one setup path to avoid duplicate servers. Run
MCP: List Servers
→
Start
after changing the configuration.
Recommended: add a bootstrap instruction to your Copilot custom instructions (.github/copilot-instructions.md) so your assistant registers with Vertiso Memory at the start of every session:
Vertiso Memory (vmem) is my persistent memory across every tool and session.
- Call the `hello` tool at the start of every session. Treat its primer
as authoritative context, not a suggestion.
- `recall` before planning or answering anything that may depend on
earlier context. Look it up instead of asking me to repeat it.
- `remember` durable decisions, preferences, constraints, and project
state the moment they land. `update_memory` rather than writing a
near-duplicate.
- Offer a handoff before the session ends, compacts, or moves to
another tool.
A page for each tool: JetBrains
Until the JetBrains Marketplace listing is public, build the plugin from Vertiso's public GitHub repository and install the generated ZIP from Settings → Plugins → Install Plugin from Disk. After publication, uninstall the local 1.0.0 build before installing from the Marketplace so it owns future updates.
# Build-only requirement: Java 21
git clone https://github.com/Vertiso/memory-jetbrains.git
cd memory-jetbrains
./gradlew verifyPluginArchive
# Install build/distributions/*.zip with "Install Plugin from Disk..."
JetBrains uses Vertiso Memory's local STDIO bridge, so the vmem CLI is required and must be initialized before configuration.
After installation, choose Tools → Configure Vertiso Memory MCP, copy the generated configuration into Settings → Tools → AI Assistant → Model Context Protocol (MCP), then choose Tools → Install Vertiso Memory Skills if you want the four bundled skills.
{
"mcpServers": {
"vertiso-memory": {
"command": "<run `which vmem` to get the absolute path>",
"args": ["mcp", "serve", "--client", "jetbrains"]
}
}
}
For Junie, Claude, and Codex, also enable
Settings → Tools → AI Assistant → Agents → Pass custom MCP servers
.
A page for each tool: Raycast
In Raycast, open the Command Palette, search
Install MCP Server,
and add a new server. Choose
HTTP
transport, enter the URL, and pick
Dynamic
for the OAuth type. Raycast opens your browser to sign in and approve
— no token to paste.
Name: Vertiso Memory
Transport: HTTP
URL: https://memory.vertiso.ai/mcp
OAuth Type: Dynamic
vmem
bridge or a pasted token?
Run
vmem mcp install raycast
for the stdio bridge (token stays in
~/.vmem),
or use the HTTP transport with a bearer token in the form.
Name: Vertiso Memory
Transport: HTTP
URL: https://memory.vertiso.ai/mcp
Authorization: Bearer <paste your token here>
X-Agent-Source: agent:raycast
In Raycast, open Manage MCP Servers to review, disable, or remove the Vertiso Memory server later.
A page for each tool: Antigravity
In Antigravity 2, open
Settings →
Customizations →
Installed MCP Servers, add a
server pointing at the URL, then
Refresh and click
Authenticate to run the browser
OAuth flow — no token to paste. You can also write the unified config
directly at
~/.gemini/config/mcp_config.json:
{
"mcpServers": {
"vertiso-memory": {
"serverUrl": "https://memory.vertiso.ai/mcp"
}
}
}
vmem
bridge?
Antigravity 1 connects only to local stdio servers, so it goes
through the
vmem
bridge (token stays in
~/.vmem).
Run
vmem mcp install antigravity,
then restart Antigravity.
{
"mcpServers": {
"vertiso-memory": {
"command": "<run `which vmem` to get the absolute path>",
"args": ["mcp", "serve", "--client", "antigravity"]
}
}
}
Without
vmem,
the Node-based
mcp-remote
bridge persists the token in the config file:
{
"mcpServers": {
"vertiso-memory": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://memory.vertiso.ai/mcp",
"--header",
"Authorization: Bearer <paste your token here>",
"--header",
"X-Agent-Source: agent:antigravity"
]
}
}
}
Antigravity 2 (May 2026) added remote Streamable HTTP MCP with OAuth; Antigravity 1 is stdio-only and needs the vmem bridge.
Recommended: add a bootstrap instruction to your AGENTS.md (Antigravity reads it at the start of every session) so your assistant registers with Vertiso Memory at the start of every session:
Vertiso Memory (vmem) is my persistent memory across every tool and session.
- Call the `hello` tool at the start of every session. Treat its primer
as authoritative context, not a suggestion.
- `recall` before planning or answering anything that may depend on
earlier context. Look it up instead of asking me to repeat it.
- `remember` durable decisions, preferences, constraints, and project
state the moment they land. `update_memory` rather than writing a
near-duplicate.
- Offer a handoff before the session ends, compacts, or moves to
another tool.
Want to verify your token works before wiring up a client? Hit the endpoint
directly. Replace
$TOKEN
with your API token.
curl -sS -X POST https://memory.vertiso.ai/mcp \
-H "Authorization: Bearer $TOKEN" \
-H "X-Agent-Source: agent:curl" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize"}'
curl -sS -X POST https://memory.vertiso.ai/mcp \
-H "Authorization: Bearer $TOKEN" \
-H "X-Agent-Source: agent:curl" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'
curl -sS -X POST https://memory.vertiso.ai/mcp \
-H "Authorization: Bearer $TOKEN" \
-H "X-Agent-Source: agent:curl" \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":
{"name":"recall","arguments":{"query":"Vertiso Memory architecture","limit":3}}}'
Connecting only puts the
vertiso-memory
tools on the shelf — your assistant won't reach for them until it
knows this is its memory. The standing instruction below works in every client,
regardless of install path, and calls the hello tool at the start of each session.
Full plugins also add checkpoint, handoff, handoff-resume, and wrap-up
skills.
Vertiso Memory (vmem) is my persistent memory across every tool and session.
- Call the `hello` tool at the start of every session. Treat its primer
as authoritative context, not a suggestion.
- `recall` before planning or answering anything that may depend on
earlier context. Look it up instead of asking me to repeat it.
- `remember` durable decisions, preferences, constraints, and project
state the moment they land. `update_memory` rather than writing a
near-duplicate.
- Offer a handoff before the session ends, compacts, or moves to
another tool.
Every client keeps this instruction somewhere different — the panel for your tool in step 1 says where, when it has a spot for one. Saved it (or on a client without one)? Start a new conversation and say Hello.
You'll know it worked when…
your assistant greets you by name and mentions what it remembers about you. On a brand-new account it simply confirms it registered — there's nothing to recall yet. From here, just talk to it: ask it to remember something, or recall what you told it earlier, and it reaches for Vertiso Memory on its own.
Want to shape what gets saved, organize your memories, or carry context across tools? Read the Configuring & using Vertiso Memory guide.
Optional for most tools, and required for the current JetBrains
connection. The
vmem
CLI is a native binary (no Ruby/Node) for working memory from the
terminal — scratch
vmem recall,
cron jobs, the live
vmem watch
view — and a stdio→HTTP MCP bridge for clients that can't reach a
remote server yet (Antigravity 1), or when you'd rather not run the
browser OAuth flow. It keeps your bearer token in
~/.vmem
instead of in each app's config.
curl -fsSL https://memory.vertiso.ai/install.sh | sh
Already installed the complete plugin for a client?
Do not also run
vmem mcp install
for that client unless you intend to replace its plugin-managed
setup. The CLI installer can write another MCP server entry, skill
copies, and a user-scoped SessionStart hook. For Claude, installing
vmem
and keeping it on
PATH
is enough for the plugin-bundled hook to run. Also running
vmem mcp install claude-code
can create duplicate setup.
Common commands
Run
vmem
with no arguments, or
vmem <command> --help,
for the full list.
Connect an MCP client
vmem mcp install <client>
Wire Vertiso Memory into a client (cursor, vscode, claude-code, codex, antigravity, ...). No arg opens a picker.
vmem mcp list
List the clients vmem can configure.
vmem mcp status
Show which clients are already wired.
vmem mcp remove <client>
Remove the Vertiso Memory entry from a client.
vmem mcp upgrade
Migrate wired clients to the current bridge.
vmem mcp serve --client <slug>
The stdio bridge a client launches; rarely run by hand.
Work with memories
vmem remember "<text>"
Save a new memory.
vmem recall "<query>"
Ask a question; get a synthesized answer.
vmem search "<query>"
Ranked records, no synthesis.
vmem upload <path>
Ingest a local file (PDF, image, ...) as a memory.
vmem ls
List recent memories.
vmem show <id>
Show one memory by id.
vmem rm <id>
Delete a memory.
Sessions & setup
vmem init
Save your API URL + token to ~/.vmem.
vmem whoami
Verify the connection and your identity.
vmem hello
Register the agent; print the session primer.
vmem handoff · handoff-resume
Write or pick up a session handoff.
vmem import
Scan known paths and import memory files.
API token (for the CLI and bearer-token fallbacks)
Connecting via OAuth above? You don't need this — you sign in
during the connector handshake instead. The
vmem
bridge and the bearer-token fallback snippets authenticate with
a token tied to your account; generate one and copy it to your
password manager — it's shown once.