> ## Documentation Index
> Fetch the complete documentation index at: https://docs.virtuous.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Contextual Menu

> The per-page menu that lets you copy docs as Markdown, open the current page in ChatGPT or Claude, copy the MCP server URL, and connect AI tools like Cursor and VS Code with one click

The **Contextual Menu** is the page-level menu that gives you quick ways to take the page you're reading and use it elsewhere — pull it into ChatGPT, send it to Claude, open it in Cursor, copy it as Markdown for your team docs, or grab the MCP server URL for any other tool. It's especially useful for partners working across multiple AI tools.

This page covers every option in the menu, when to use which, and the workflows that emerge from having these in one click.

## Where the menu lives

The contextual menu appears as a button on each page — typically at the top of the page near the title, or in the table of contents sidebar (depending on configuration). Click it to expand a list of options.

| Action                 | Result                                                       |
| ---------------------- | ------------------------------------------------------------ |
| Click the menu button  | Expands the menu of options for the current page             |
| Click an option        | Performs the action (copy, open in tool, install connection) |
| Click outside the menu | Collapses without action                                     |

The menu's options apply to the page you're currently on. The action takes the content of the current page and routes it to wherever you've selected.

## What's in the menu

The contextual menu groups capabilities into a few categories:

| Category                   | Options                                                                          |
| -------------------------- | -------------------------------------------------------------------------------- |
| **Copy and view**          | Copy the page as Markdown; view the page as Markdown                             |
| **AI Assistant (in-docs)** | Open the in-docs AI Assistant with this page as context                          |
| **External AI chats**      | Open the page directly in ChatGPT, Claude, Perplexity, Grok, or Google AI Studio |
| **AI development tools**   | Open the page in Devin or Windsurf                                               |
| **MCP server**             | Copy the MCP server URL; copy the install command; connect to Cursor or VS Code  |

The exact options visible may vary depending on the Virtuous docs configuration, but the categories above are representative.

## When to use each option

Different options fit different workflows. A quick decision guide:

| You want to...                                               | Use                                                                                     |
| ------------------------------------------------------------ | --------------------------------------------------------------------------------------- |
| Read the page in a clean text format                         | **View as Markdown**                                                                    |
| Paste the page into your team's wiki or internal docs        | **Copy page** (gets Markdown)                                                           |
| Ask an AI a question about this page in the docs site itself | **Ask assistant** (opens the in-docs [AI Assistant](/virtuous/docs-guide/ai-assistant)) |
| Ask ChatGPT a question with this page as context             | **Open in ChatGPT**                                                                     |
| Ask Claude a question with this page as context              | **Open in Claude**                                                                      |
| Use Perplexity for research with this page as context        | **Open in Perplexity**                                                                  |
| Use Grok with this page as context                           | **Open in Grok**                                                                        |
| Use Google AI Studio with this page as context               | **Open in Google AI Studio**                                                            |
| Open the page in Devin for an autonomous coding session      | **Open in Devin**                                                                       |
| Open the page in Windsurf Cascade                            | **Open in Windsurf**                                                                    |
| Get the MCP server URL to paste into any AI tool             | **Copy MCP server URL**                                                                 |
| Get a one-line install command for the MCP server            | **Copy MCP install command**                                                            |
| Set up Cursor to query the docs while you code               | **Connect to Cursor**                                                                   |
| Set up VS Code (Copilot) to query the docs while you code    | **Connect to VS Code**                                                                  |

The pattern: **one click takes the current page (or the MCP server connection) and routes it where you want it**.

## Copy and view options

### Copy page

Copies the entire current page to your clipboard as Markdown. Useful for:

| Use case                                       | Workflow                                                  |
| ---------------------------------------------- | --------------------------------------------------------- |
| Pasting into your team's internal docs         | Copy the page, paste into Notion / Confluence / your wiki |
| Pasting into an AI chat you're already in      | Copy the page, paste into the AI tool with your question  |
| Reviewing offline                              | Copy the page, paste into your text editor                |
| Including in support tickets or partner emails | Copy the relevant page, include for shared context        |

The Markdown preserves the structure (headings, tables, code blocks) so the pasted content stays readable.

### View as Markdown

Opens the current page rendered as plain Markdown in your browser. Useful for:

* Reading without the docs site's chrome
* Copying specific sections (you can select and copy from the Markdown view)
* Verifying what content the page actually contains (vs. what's rendered visually)
* Sharing a link that someone can read in any Markdown viewer

The URL of the Markdown view is shareable.

## External AI chat options

Each of these options takes the current page and opens a new chat in the named tool, with the page already loaded as context. You can then ask any question about it.

### Open in ChatGPT

Opens a new ChatGPT conversation with the page as context. You're routed to ChatGPT in a new tab. Ask any question; ChatGPT uses the page content as its starting reference.

### Open in Claude

Same pattern with Claude. Useful when:

* Your team standardizes on Claude
* You want to use Claude's Projects feature with docs content
* You need longer responses than other tools provide

### Open in Perplexity

Same pattern with Perplexity. Useful when:

* You want web-connected research alongside docs content
* You're comparing Virtuous patterns to other tools or approaches

### Open in Grok / Google AI Studio

Same pattern with each of these tools. Use whichever your team is already standardized on.

| Workflow pattern                                                           | Why this matters                   |
| -------------------------------------------------------------------------- | ---------------------------------- |
| You're reading a docs page → want to brainstorm with an AI                 | One click, no manual copy-paste    |
| You hit a tricky concept → want a second opinion from an AI                | One click takes the page to the AI |
| You're explaining the docs to a teammate via chat → AI helps you summarize | Send to AI, use the AI's summary   |

## AI development tool options

For partners doing actual coding work, two options route the docs to coding-focused AI tools:

### Open in Devin

Opens a Devin session with the page as context. Useful for:

* Asking Devin to scaffold an integration based on documented patterns
* Generating boilerplate code grounded in the docs
* Refactoring existing code to match documented best practices

### Open in Windsurf

Opens Windsurf Cascade with the page as context. Useful for:

* Working in Windsurf as your primary IDE
* Treating the docs page as a working reference while you build

For partners using Cursor or VS Code specifically, the **Connect to Cursor** and **Connect to VS Code** options below are usually a better fit — they set up persistent docs access rather than per-page context.

## MCP server options

These options connect AI tools to the [MCP server](/virtuous/mcp/overview), which gives them persistent docs access (not just per-page context).

### Copy MCP server URL

Copies the MCP server URL (`https://docs.virtuous.org/mcp`) to your clipboard. Useful for:

* Pasting into AI tools that don't have a one-click install button
* Setting up a custom MCP-compatible tool
* Sharing the MCP URL with a teammate setting up their own tool

### Copy MCP install command

Copies a one-line install command (`npx add-mcp ...`) for AI tools that support `npx`-based MCP installation. Useful when:

* You're setting up a new tool and prefer command-line installation
* You're sharing the install with a teammate via Slack

### Connect to Cursor

Installs the Virtuous docs MCP server in Cursor with one click. After clicking:

1. Cursor opens (if it's installed)
2. The MCP server is added to your Cursor configuration
3. From now on, Cursor's AI can query the Virtuous docs while you code

This is the fastest way to set up the docs MCP server in Cursor — no manual JSON editing.

For the detailed walkthrough of how MCP servers work in Cursor, see [Connect to the Virtuous MCP Server](/virtuous/mcp/connect).

### Connect to VS Code

Same pattern for VS Code. One click installs the MCP server into your VS Code configuration; the Copilot chat can then query the docs.

| Workflow this enables                                             | How it changes your day                                            |
| ----------------------------------------------------------------- | ------------------------------------------------------------------ |
| Cursor knows the Virtuous docs while you code                     | Ask Cursor questions naturally; it cites docs rather than guessing |
| VS Code Copilot knows the Virtuous docs                           | Same — but in VS Code                                              |
| You're explaining your integration to a teammate via screen share | Ask the AI on-screen with full docs context                        |

For the underlying details on what the MCP server provides, see the [MCP Overview](/virtuous/mcp/overview).

## Workflow combinations

The contextual menu shines when you combine its options with your existing workflows. A few patterns:

### "Triaging a customer issue"

1. Open the relevant docs page
2. **Copy page** to grab the Markdown
3. Paste into your support ticketing system with the customer's question
4. Engineers reviewing the ticket see the docs context alongside the issue

### "Writing partner-side documentation"

1. Open the Virtuous docs page covering the related Virtuous concept
2. **Copy page** to your clipboard
3. Paste into your own integration docs as a starting point
4. Edit down to match your customer-facing voice
5. Link back to the Virtuous source for readers who want to go deeper

### "Onboarding a new engineer to your integration"

1. Send them a deep-link to the Virtuous docs page covering the relevant API
2. They use **Open in ChatGPT** (or whichever AI tool your team uses) to ask questions
3. Or they use **Connect to Cursor** to wire up persistent docs access in their IDE
4. Either way, they're up to speed faster

### "Deep researching across multiple sources"

1. Open the Virtuous docs page you're researching from
2. **Open in Perplexity** to combine the docs with web research
3. Cross-reference what you learn against other tools' approaches
4. Bring conclusions back to your integration design

### "Code generation grounded in docs"

1. Open the docs page covering the workflow you want to implement
2. **Open in Claude** or **Open in ChatGPT**
3. Ask: "Generate the JavaScript code for this workflow, following the documented patterns"
4. Copy the generated code into your IDE
5. Verify by following the citations back to the docs

## The contextual menu vs. other options

A quick comparison of the four AI-related capabilities the docs offer:

| Capability                                            | How it works                                                              | When it shines                                               |
| ----------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------ |
| [**AI Assistant**](/virtuous/docs-guide/ai-assistant) | In-docs chat; asks questions of the docs from within the docs site        | Quick questions while reading; no tool-switching             |
| [**MCP server**](/virtuous/mcp/overview)              | External AI tools (Cursor, Claude Code, etc.) query the docs in real time | Persistent docs access while you code in your IDE            |
| **Contextual Menu (this page)**                       | Per-page handoff to external AI tools with one click                      | Quick handoff of a specific page to a specific external tool |
| **Copy page / View as Markdown**                      | Get the page's text for any use                                           | Pasting into wikis, support tickets, manual AI conversations |

These are complementary — use whichever fits the moment. The contextual menu specifically removes friction for handing off **a specific page** to **a specific external destination**.

## Tips for getting the most out of the contextual menu

A few patterns worth knowing:

| Tip                                              | Why                                                                                                    |
| ------------------------------------------------ | ------------------------------------------------------------------------------------------------------ |
| **Use Copy page when in doubt**                  | The Markdown export is universal — works with any AI tool, any wiki, any text editor                   |
| **Use one-click connections for Cursor/VS Code** | Faster than manual config; same result                                                                 |
| **Use Open in \[Tool] for one-off questions**    | When you need an answer in your standard AI tool but don't need ongoing docs access                    |
| **Combine with the AI Assistant**                | The in-docs assistant for quick questions; external tools for code generation or longer reasoning      |
| **Bookmark the result URLs**                     | When you've routed a useful page into an AI tool, the resulting conversation often has a shareable URL |

## When the menu's not in the right place

A few minor things to know:

| Question                               | Answer                                                                                                                                 |
| -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| Why don't I see the menu on this page? | Some pages may have it placed in the table of contents sidebar rather than the page header; check the right side of the page           |
| Why isn't the option I want there?     | The menu's options are configured for the docs as a whole; what's available is what you see                                            |
| Why doesn't "Open in \[Tool]" work?    | The destination tool must be available — for native apps, that means installed; for web tools, that means accessible from your browser |
| Why doesn't "Connect to Cursor" work?  | Cursor must be installed; if it's not, the one-click install can't open it                                                             |

For troubleshooting AI tool connections specifically, see [Connect to the Virtuous MCP Server](/virtuous/mcp/connect#troubleshooting).

## Where to go next

<CardGroup cols={2}>
  <Card title="MCP Overview" icon="plug" href="/virtuous/mcp/overview">
    The persistent docs-AI integration that the contextual menu's "Connect to..." options set up.
  </Card>

  <Card title="AI Assistant" icon="message-bot" href="/virtuous/docs-guide/ai-assistant">
    The in-docs AI chat — different from the contextual menu's external handoff options.
  </Card>

  <Card title="Search and Navigation" icon="magnifying-glass" href="/virtuous/docs-guide/search-and-navigation">
    Finding the page you want to apply the contextual menu to.
  </Card>

  <Card title="API Playground" icon="play" href="/virtuous/docs-guide/api-playground">
    The interactive endpoint testing built into the docs.
  </Card>
</CardGroup>
