@hybridlabor-api/aos 4.2.0 → 4.4.0

package/mcps/RhinoMCP/docs/content/docs/developers/upgrade-gh1-to-gh2.md

@@ -1,98 +0,0 @@
----
-title: Upgrade Grasshopper components to GH2
-linkTitle: Upgrade GH1 to GH2
-weight: 3
-author: Callum
-keywords:
-  - Grasshopper
-  - GH1 to GH2
-  - plugin components
-  - upgrade
----
-
-![Voxelizer GH1 component and its GH2 equivalent solving side by side](/developer/voxelizer-gh2-conversion.png)
-
-Rhino 9 ships Grasshopper 2 alongside Grasshopper 1. If you have a GH1 plugin and you want to try upgrading to GH2, this is a perfect use of an AI agent and the Rhino MCP server. The MCP exposes parallel `g1_*` and `g2_*` tool families, so the assistant can place a GH1 component and its new GH2 counterpart on their respective canvases in the same session and compare what they solve to.
-
-We'll use Voxelizer as the running example: a small, single-component GH1 plugin that's easy to follow end to end.
-
-{{< github "https://github.com/ytakzk/Voxelizer" >}}
-
-## The loop
-
-With both canvases reachable, the assistant can:
-
-- Read each GH1 component's inputs, outputs, and solve logic.
-- Scaffold a GH2 equivalent in a new folder, leaving the GH1 sources untouched.
-- Place the GH1 component on a GH1 canvas with sample inputs, place the new GH2 component on a GH2 canvas with the same inputs, and compare outputs through the MCP.
-- Iterate until both solve the same way, then move to the next component.
-
-The side-by-side check matters: GH2's parameter and data-tree conventions aren't a one-for-one match with GH1, so "it compiles and places" isn't enough on its own.
-
-## A prompt to start with
-
-{{< prompt >}}
-Add a GH2 port of this plugin in a folder called `gh2/` in this repo. The GH1
-project must build untouched.
-
-Use McNeel's official template, not hand-rolled scaffolding:
-  dotnet new install Rhino.Templates
-  dotnet new gh2 --IncludeSample false -n <PluginName>Gh2 -o <plugin-name>.gh2
-
-Reference docs while porting:
-  Guide:    https://developer.rhino3d.com/guides/grasshopper2/your-first-component-mac/
-  Template: https://github.com/mcneel/RhinoVisualStudioExtensions/tree/main/Rhino.Templates/content/CSGrasshopper2
-
-Discover, don't assume:
-  - Find the GH1 csproj and list every GH_Component subclass — these
-    are what you port.
-  - Identify any helper classes that only depend on RhinoCommon (no
-    `Grasshopper.Kernel.*`). These should be SHARED, not copied:
-      <Compile Include="..\<gh1-folder>\<file>.cs" Link="Shared\..." />
-    If there are no such helpers, skip this step.
-  - Note each component's inputs and outputs (types, access mode) —
-    you'll need this for both the port and the comparison.
-
-Port one component at a time. For each:
-  1. Generate or write the GH2 component shell (Component subclass,
-     [IoId], Nomen, AddInputs/AddOutputs/Process). Preserve the
-     original GH1 ComponentGuid by reusing it as the [IoId] value —
-     this keeps any existing GH1 documents that reference it
-     identifiable for future upgrade tooling.
-  2. Build (.rhp output).
-  3. Validate via rhino-mcp:
-       - spawn one Rhino WIP
-       - place the GH1 component on the GH1 canvas
-       - place the GH2 component on the GH2 canvas
-       - feed both the same fixture: minimal, deterministic, picked
-         based on the component's input types (e.g. a slider for
-         numbers, `Mesh Without Normals` for meshes, native geometry
-         components for curves/surfaces). If a fixture cannot be
-         expressed natively, commit it as a .3dm under
-         tests/fixtures/ and load via the MCP.
-       - solve both, then compare outputs by type:
-           lists/trees: structure (branch + leaf counts) must match
-                        exactly
-           numeric:     within abs tolerance (default 1e-9) or rel
-                        tolerance the agent justifies inline
-           geometry:    bbox + element count must match exactly;
-                        per-element drift within tolerance is warn,
-                        not fail
-           bools/ints:  exact equality
-       - Mismatch in structure or count = hard fail. Per-element
-         drift within tolerance = warn-only.
-
-### Constraints:
-  - Don't modify any file under the GH1 source folder.
-  - If anything is unclear before you start, ask. Don't infer.
-{{< /prompt >}}
-
-## What to review
-
-- **Parameter types.** GH2's type system isn't identical to GH1's; check that the assistant picked the right GH2 type rather than the closest-named one.
-- **Data-tree handling.** If your GH1 component does anything non-trivial with branches or paths, look at how that translates. This is the most common place for "solves but wrong" bugs.
-- **Component metadata.** Names, categories, icons, GUIDs: easy to get wrong, hard to fix later once users have files referencing them.
-
-## When the assistant gets stuck
-
-If a component doesn't have a clean GH2 equivalent (or relies on a GH1 API that's gone), have the assistant skip it and surface the list of skipped components at the end, rather than trying to fake it. A short "these need human eyes" list is more useful than a stubbed component that silently solves to nothing.

package/mcps/RhinoMCP/docs/content/docs/developers/upgrade-to-netcore.md

@@ -1,53 +0,0 @@
----
-title: Upgrade a plugin to .NET Core
-linkTitle: Upgrade to .NET Core
-weight: 1
-prev: docs/developers
-author: Callum
-editor: SteveF
-keywords:
-  - .NET Core
-  - plugin upgrade
-  - net48
-  - Claude Code
----
-
-![sel-commands](/developer/sel-arc.png)
-
-If you have a Rhino plugin still targeting `net45` or `net48`, you'll want to move it to `net8.0` (Rhino 8) which will also work for (Rhino 9 WIP/BETA). This page showcases how you can use the RhinoMCP to make this upgrade seamless.
-
-## An Example
-
-As an example we'll upgrade this simple `net45` plugin written by [Steve Baer](https://discourse.mcneel.com/u/stevebaer/summary). Checkout the code, and open your AI agent at the path of the locally cloned repo.
-
-{{< github "https://github.com/sbaer/selcommands" >}}
-
-## The prompt
-
-{{< prompt >}}
-Upgrade this legacy RhinoCommon plugin to a modern Rhino 8 plugin per the
-McNeel CSRhino template:
-https://github.com/mcneel/RhinoVisualStudioExtensions/tree/main/Rhino.Templates/content/CSRhino
-
-- SDK-style csproj, net8.0;net48, EnableDynamicLoading,
-  TargetExt=.rhp, RhinoCommon via NuGet (ExcludeAssets="runtime")
-- Move Title/Company/Description/Version into the csproj; keep PlugInDescription
-  attrs and the original Guid in AssemblyInfo.cs
-- Ensure the necessary debug launch profiles exist for vscode and Visual Studio from the template
-- Don't touch command sources unless an API changed
-- `dotnet build` to verify both target frameworks
-{{< /prompt >}}
-
-## The AI Agent
-
-With this prompt the AI agent will read through and update all of the necessary files in the repo, mostly `.csproj` and `.cs` files. It will also test using `dotnet build` to ensure the code works. When the code builds the agent will load the `.rhp` into Rhino and can run commands to ensure it worked. If Rhino crashes, the AI Agent should get the crash info and can figure out why it crashed and resolve it.
-
-
-## What to review
-
-When your AI Assistant is done it is very important to review all of the changes made and make an effort to understand them. Some important items to review.
-
-- **The new `.csproj`.**
-- **Directory.Build.Props.**
-- **Updated Nuget references**
-- **Any updated commands**

package/mcps/RhinoMCP/docs/content/docs/developers/windows-to-cross-platform.md

@@ -1,58 +0,0 @@
----
-title: Make a Windows-only plugin cross-platform
-linkTitle: Windows to cross-platform
-weight: 5
-author: Callum
-editor: SteveF
-draft: true
-keywords:
-  - cross-platform
-  - Mac
-  - P/Invoke
-  - plugin port
----
-
-// https://github.com/mcneel/RhinoVR
-
-If your Rhino plugin currently only runs on Windows, getting it onto Mac is usually a mix of UI work (WPF → Eto) and a long tail of small non-UI Windows-isms: P/Invokes into `user32`/`kernel32`, registry reads, COM interop, `\\`-style paths, `System.Drawing` assumptions, and the like. This page is about the non-UI half; for the UI half see [Convert a WPF UI to Eto](wpf-to-eto).
-
-## The loop
-
-With Rhino MCP loaded, the assistant can:
-
-- Grep the codebase for the usual Windows-only suspects (`DllImport`, `Microsoft.Win32`, `System.Windows.*`, `Marshal`, hard-coded `C:\` paths) and work through them one at a time.
-- Replace each with a portable equivalent, usually a RhinoCommon or Eto API, sometimes plain BCL, occasionally a small `RuntimeInformation` switch when there's genuinely no shared path.
-- Build, load the `.rhp` into the running Rhino, and run the affected command to confirm the replacement actually works on the target platform.
-
-The "actually run it on Mac" step is what makes this worth doing through the MCP. A lot of Windows-isms compile fine on .NET on Mac and only blow up at runtime when the P/Invoke can't resolve.
-
-## A prompt to start with
-
-{{< prompt >}}
-This is a Rhino plugin that only runs on Windows. I want it working on
-Mac as well. Find the Windows-specific code (P/Invokes, registry
-access, COM interop, `System.Windows.*` references, hard-coded Windows
-paths) and replace each with a cross-platform equivalent
-(RhinoCommon, Eto, or plain .NET). Work one site at a time, build after
-each change, load it into the Rhino I have open and run the affected
-command to confirm it still works. Show me the diff before each file
-change, and at the end give me a list of anything you couldn't port.
-{{< /prompt >}}
-
-If the plugin has a WPF UI, do that port first (or in parallel in a separate session), otherwise the build won't come up on Mac at all and the assistant can't close its loop.
-
-## What to review
-
-- **P/Invoke removals.** A `DllImport` into `user32` usually has a RhinoCommon or Eto equivalent; confirm the replacement has the same behavior, not just the same shape. Things like window activation, cursor position, and clipboard access all have portable APIs but with slightly different semantics.
-- **Registry usage.** `Microsoft.Win32.Registry` is Windows-only. Settings should generally move to `PlugIn.Settings` (RhinoCommon) or a file under a portable location like `Rhino.ApplicationSettings`'s data folder. Watch for license/activation state that was stored in the registry. That needs a deliberate decision, not just a reflexive port.
-- **File paths.** `Path.Combine` and forward slashes are fine on both platforms; hard-coded `C:\Users\...` or `%APPDATA%` is not. Mac uses `~/Library/Application Support/...` for the equivalent data, and RhinoCommon exposes the right folders directly.
-- **`System.Drawing` quirks.** `System.Drawing.Common` works on Mac but some bits (printing, GDI+ specifics) don't. If the plugin does non-trivial image work, prefer Eto's drawing APIs.
-- **COM interop.** Office automation, Shell COM objects, anything `Marshal.GetActiveObject`: none of this exists on Mac. These usually need a real redesign, not a port. Flag them and decide per-feature whether to drop, gate, or replace.
-- **Conditional compilation.** Some Windows-only features genuinely have no Mac equivalent. `RuntimeInformation.IsOSPlatform(...)` at runtime is usually cleaner than `#if WINDOWS` at compile time, because the same assembly ships to both platforms.
-- **The `.csproj`.** Check that nothing pins the build to `win-x64` / `net8.0-windows` unless it has to. The plugin should build as plain `net7.0` / `net8.0` so the same `.rhp` runs on both.
-
-## When the assistant gets stuck
-
-If a feature genuinely has no Mac equivalent (a Windows-only license dongle, an Office automation feature, a driver-level integration), have the assistant gate it behind a runtime platform check and surface it in the "couldn't port" list rather than stubbing silently. A feature that's clearly Windows-only with a polite message is much better than one that appears to work and quietly does nothing.
-
-For anything that compiles on Mac but fails at runtime, ask the assistant to reproduce the failure through the MCP first (running the command, reading the error) before proposing a fix. The MCP is what keeps it honest about which "fixes" actually fix anything.

package/mcps/RhinoMCP/docs/content/docs/developers/wpf-to-eto.md

@@ -1,64 +0,0 @@
----
-title: Convert a WPF UI to Eto
-linkTitle: WPF to Eto
-weight: 6
-next: docs/troubleshooting
-author: Callum
-editor: SteveF
-draft: true
-keywords:
-  - WPF
-  - Eto.Forms
-  - cross-platform UI
-  - Mac
----
-
-// Use https://github.com/dalefugier/SampleCsChromium
-
-If your Rhino plugin's UI is built on WPF, it only runs on Windows. Porting it to [Eto.Forms](https://github.com/picoe/Eto), the cross-platform UI toolkit Rhino itself uses, lets the same plugin run on Rhino for Mac as well. The mechanical parts of that port (rewriting XAML as Eto layouts, swapping bindings, re-wiring event handlers) are a great fit for Claude Code with Rhino MCP, because the assistant can build the plugin, load it into Rhino, and actually open each dialog to see whether it renders.
-
-## What you need
-
-- **Claude Code** with the [Rhino MCP plugin](../getting-started/cc-plugin) installed.
-- **Rhino** open with Rhino MCP running. If you can run it on both Windows and Mac, even better. The whole point of the port is the Mac side.
-- Your plugin's source checked out locally, with Claude Code started in that repo.
-
-## The loop
-
-With Rhino MCP loaded, the assistant can:
-
-- Read your existing `.xaml` and code-behind files and map controls to their Eto equivalents.
-- Scaffold an Eto `Dialog` or `Panel` per WPF window, rebuild, and load the `.rhp` into Rhino.
-- Run the command that opens each dialog and confirm it actually appears, rather than just compiles.
-- Iterate on layout and bindings one panel at a time.
-
-Opening the dialog after each change is what makes this worth doing through the MCP. Eto's layout model isn't WPF's, and "it builds" tells you very little about whether the result is usable.
-
-## A prompt to start with
-
-{{< prompt >}}
-Convert a legacy Rhino WinForms plug-in to Rhino 8 / net8.0 / Eto.Forms.
-
-SDK-style csproj: net8.0, <TargetExt>.rhp</TargetExt>, <GenerateAssemblyInfo>false</GenerateAssemblyInfo>, single RhinoCommon 8.x PackageReference. Drop packages.config, post-build hacks, per-arch configs.
-Replace WinForms controls with Eto.Forms equivalents. Preserve any panel [Guid].
-git rm *.Designer.cs, *.resx, Resources.*, packages.config.
-Collapse .sln to Any CPU with SDK project type GUID.
-Add .vscode/launch.json + tasks.json from the Rhino template.
-Verify dotnet build is clean.
-{{< /prompt >}}
-
-If you have a mix of dialogs and dockable panels, tell the assistant which is which. Eto's `Dialog` and Rhino's panel hosting are different code paths.
-
-## What to review
-
-- **Layout translation.** WPF's `Grid` with star-sizing, `StackPanel`, and `DockPanel` don't map one-for-one to Eto's `TableLayout`, `StackLayout`, and `DynamicLayout`. Open each ported dialog and check spacing, alignment, and what happens when you resize.
-- **Data binding.** WPF's `{Binding}` and `INotifyPropertyChanged` flow doesn't exist in Eto the same way. The assistant will often replace bindings with explicit event wiring. Confirm two-way fields still round-trip.
-- **Styles and resources.** WPF `Style`, `ResourceDictionary`, and control templates have no direct Eto equivalent. Expect these to collapse into per-control property setters; spot-check the visual result.
-- **Platform-specific code-behind.** Anything reaching into `System.Windows.*` (clipboard, dispatcher, message boxes) needs an Eto or RhinoCommon replacement, not a `#if WINDOWS` wrapper.
-- **Rhino panel registration.** If a window is hosted as a Rhino panel, the registration attributes and panel GUIDs need to come across too, not just the UI class.
-
-## When the assistant gets stuck
-
-If a control has no clean Eto equivalent (custom-drawn WPF controls, heavy `ItemsControl` templating, third-party WPF libraries), have the assistant stop and surface the list rather than faking it with a `Label` that says "TODO". A short "these need a human" list is more useful than a dialog that opens but does nothing.
-
-For visual diffs, ask the assistant to open the same dialog before and after on the same Rhino session so you can eyeball the difference. The MCP can drive that, but it can't tell you whether the new layout *looks* right.

package/mcps/RhinoMCP/docs/content/docs/getting-started/_index.md

@@ -1,45 +0,0 @@
----
-title: Getting Started
-icon: play
-weight: 1
-prev: /
-next: docs/getting-started/connector
-toc: false
-author: Callum
-editor: SteveF
-keywords:
-  - getting started
-  - installation
-  - setup
-  - AI assistant
----
-
-<blockquote class="page-alert">
-This guide assumes you have <a href="https://www.rhino3d.com/download/">Rhino 3D</a> already installed and licensed.
-</blockquote>
-
-In about ten minutes you'll have your AI assistant making geometry in your Rhino and/or Grasshopper window. We'll do it in a couple steps:
-
-## Pick an AI assistant
-
-Any AI assistant that speaks the [Model Context Protocol](https://modelcontextprotocol.io) can drive Rhino & Grasshopper. *Choose one of the AI assistants below to continue.*
-
-{{< cards >}}
-
-  {{< card link="connector" icon="claude" title="Claude Desktop" subtitle="A friendly chat app from Anthropic. *Easiest to install and use.*" >}}
-
-  {{< card link="cc-plugin" icon="claude" title="Claude Code" subtitle="A terminal-based (CLI) assistant that feels more like coding than chat." >}}
-
-  {{< card link="copilot" icon="github" title="GitHub Copilot" subtitle="GitHub's AI assistant inside VS Code. Switch to Agent mode and point it to the Rhino MCP router." >}}
-
-  {{< card link="codex" icon="chatgpt" title="OpenAI Codex" subtitle="OpenAI's terminal-based assistant (CLI). Point its MCP config at the Rhino MCP router and go." >}}
-
-  {{< card link="gemini" icon="gemini" title="Gemini CLI" subtitle="Google's open-source terminal assistant (CLI). Drop the Rhino MCP router into its MCP config." >}}
-
-  {{< card link="lm-studio" icon="lmstudio" title="Local LLM" subtitle="Run an open-weight model on your own machine and drive Rhino & Grasshopper without Internet." >}}
-
-{{< /cards >}}
-
-<blockquote class="page-note">
-<strong>Other MCP clients work, too.</strong> <a href="https://cursor.com">Cursor</a> and other MCP-capable assistants can point at the same Rhino MCP router.
-</blockquote>

package/mcps/RhinoMCP/docs/content/docs/getting-started/cc-plugin.md

@@ -1,116 +0,0 @@
----
-title: Claude Code
-icon: claude
-weight: 3
-prev: docs/getting-started
-next: docs/try-it-out
-toc: false
-author: Callum
-editor: SteveF
-keywords:
-  - Claude Code
-  - Anthropic
-  - agents
-  - terminal
----
-
-[Claude Code](https://claude.com/claude-code) is Anthropic's terminal-based AI assistant. Claude Code is a great fit if you're comfortable in a terminal or already use it for code. If you're not sure, start with [Claude Desktop](../connector), it's much more friendly.
-
-## 1. Install Claude Code
-
-[Claude Code](https://claude.com/claude-code)
-
-## 2. Install the Rhino plugin
-
-{{< yak package="Rhino-MCP-Platform" version="8" >}}
-{{< yak package="Rhino-MCP-Platform" version="9" >}}
-
-If that doesn't work you can try the below:
-
-1. Open Rhino 8 (and/or Rhino 9 WIP/BETA)
-2. Run the `PackageManager` command
-3. Search for, and install Rhino-MCP-Platform
-
-## 3. Connect the two
-
-1. Run the `MCPConnect` command
-2. Copy and Paste the prompt into a new Claude Code session
-3. Restart Claude Code if prompted to
-
-<!--
-
-## Install the plugin
-
-Inside a Claude Code session, run:
-
-```
-/plugin marketplace add mcneel/RhinoMCP
-/plugin install mcneel@rhino-mcp
-```
-
-Restart the session when prompted. You'll see a `rhino` MCP server appear in your `/mcp` list.
-
-## What you get
-
-### Slash commands
-
-Quick actions you can fire off without writing a prompt.
-
-| Command | What it does |
-| --- | --- |
-| `/rhino-mcp:launch-rhino` | Start a Rhino instance for the session. |
-| `/rhino-mcp:launch-rhinos` | Start a few Rhino instances side by side. |
-| `/rhino-mcp:scene` | Summarize what's in the active document. |
-| `/rhino-mcp:snapshot` | Capture the viewport and describe it. |
-| `/rhino-mcp:install-mcp` | Wire the Rhino server into the current project. |
-
-### Specialist agents
-
-Each agent is tuned for a different kind of work. You can call them explicitly (*"have the modeller build me a chair"*) or let Claude pick.
-
-| Agent | What it's good at |
-| --- | --- |
-| `rhino-modeller` | Creating and editing geometry. |
-| `rhino-drafter` | Drawings, dimensions, layouts. |
-| `rhino-inspector` | Reporting on a document without changing it. |
-| `rhino-organizer` | Layers, blocks, naming, tidying up. |
-| `rhino-teacher` | Explaining Rhino concepts in plain language. |
-| `grasshopper-scripter` | Building Grasshopper definitions. |
-| `grasshopper-reviewer` | Auditing a definition for issues or simplifications. |
-| `grasshopper-teacher` | Explaining Grasshopper concepts. |
-
--->
-
-## Try it out
-
-<blockquote class="page-note">
-Open Claude Code and follow the prompts on the <a href="../../try-it-out">Try It Out</a> page.
-</blockquote>
-
-<!--
-
-## Try the agents
-
-Once that's working, see the specialist agents in action. Ask:
-
-{{< prompt >}}
-What's in my Rhino document?
-{{< /prompt >}}
-
-Claude should delegate to `rhino-inspector` and reply with a summary of layers, objects, and the viewport.
-
-Then try:
-
-{{< prompt >}}
-Modeller: design a 1.6m park bench with wooden slats and cast iron
-legs.
-{{< /prompt >}}
-
-You should see the bench appear in your Rhino window.
-
-## Tips
-
-- **Agents are colleagues, not commands.** "Hand this off to the Grasshopper scripter" works better than trying to direct every step.
-- **Multiple Rhinos.** Use `/rhino-mcp:launch-rhinos` to spin up several windows and have different agents work in each.
-
--->

package/mcps/RhinoMCP/docs/content/docs/getting-started/connector.md

@@ -1,65 +0,0 @@
----
-title: Claude Desktop
-icon: claude
-weight: 2
-prev: docs/getting-started
-next: docs/try-it-out
-toc: false
-author: Callum
-editor: SteveF
-keywords:
-  - Claude Desktop
-  - connector
-  - Anthropic
-  - setup
----
-
-[Claude Desktop](https://claude.ai/download) is Anthropic's user-friendly chat app for Windows and Mac. With our connector installed, anything you ask Claude in the chat window can now happen in Rhino & Grasshopper.
-
-## 1. Install Claude Desktop
-
-[Claude Desktop](https://claude.ai/download)
-
-## 2. Install the Claude connector
-
-1. Download [`connector.mcpb`](https://github.com/mcneel/RhinoMCP/releases/download/connector-v0.1.3/connector.mcpb).
-2. Open Claude Desktop and go to `Settings` → `Extensions` → `Advanced settings`.
-3. Click `Install Extension` and select the downloaded `connector.mcpb`.
-4. Click `Install` to confirm.
-
-That's it. The connector is now wired up.
-
-## 3. Install the Rhino plugin
-
-{{< yak package="Rhino-MCP-Platform" version="8" >}}
-{{< yak package="Rhino-MCP-Platform" version="9" >}}
-
-If that doesn't work you can try the below:
-
-## 3.b Install the Rhino plugin (with Claude)
-
-> The desktop connector can also install the plugin for you if you ask it to.
-
-Paste the following into your AI agent. It will install it for you, so there is no need to open Rhino.
-
-{{< prompt >}}
-Install the `Rhino-MCP-Platform` plugin into Rhino using Yak (Rhino's Package Manager). `$1` is the Rhino major version to target (e.g. `8`). If omitted, default to `8`.
-
-1. Locate the Yak CLI for Rhino `$1`. It ships with Rhino:
-   - macOS: `/Applications/Rhino $1.app/Contents/Resources/bin/yak`
-   - Windows: `C:\Program Files\Rhino $1\System\Yak.exe`
-2. Install the plugin from the public package server:
-   
-   `yak install Rhino-MCP-Platform`
-   
-3. Restart Rhino `$1` so the newly installed plugin is loaded.
-4. In Rhino, run the `MCPStart` command to confirm the plugin is available.
-
-To upgrade an existing install, run `yak update Rhino-MCP-Platform`. To remove it, run `yak uninstall Rhino-MCP-Platform`.
-{{</ prompt >}}
-
-## Try it out
-
-<blockquote class="page-note">
-Open Claude Desktop, start a new chat, and follow the prompts on the <a href="../../try-it-out">Try It Out</a> page.
-</blockquote>

package/mcps/RhinoMCP/docs/content/docs/getting-started/copilot.md

@@ -1,61 +0,0 @@
----
-title: GitHub Copilot
-icon: github
-weight: 4
-prev: docs/getting-started
-next: docs/try-it-out
-toc: false
-author: SteveF
-keywords:
-  - GitHub Copilot
-  - VS Code
-  - MCP
-  - agent mode
----
-
-[GitHub Copilot](https://github.com/features/copilot) in VS Code can act as an MCP client when run in **agent mode**. Point it at the Rhino MCP server and Copilot can drive Rhino directly from your editor.
-
-If you're choosing between assistants and aren't sure, start with [Claude Desktop](../connector); it's the gentler entry point.
-
-## 1. Install GitHub Copilot
-
-[VS Code 1.99](https://code.visualstudio.com) or newer, with the **GitHub Copilot** and **GitHub Copilot Chat** extensions installed and signed in. Agent mode lives in Copilot Chat: open the Chat view and switch the mode selector from **Ask** to **Agent**.
-
-## 2. Install the Rhino plugin
-
-{{< yak package="Rhino-MCP-Platform" version="8" >}}
-{{< yak package="Rhino-MCP-Platform" version="9" >}}
-
-If that doesn't work you can try the below:
-
-1. Open Rhino 8 (and/or Rhino 9 WIP)
-2. Run the `PackageManager` command
-3. Search for, and install Rhino-MCP-Platform
-
-## 3. Wire up the Rhino server
-
-1. In Rhino, run the `MCPConnect` command. It prints the command Copilot needs to launch the Rhino MCP router.
-2. In your workspace, create `.vscode/mcp.json` (or edit your User `settings.json` if you want it available everywhere).
-3. Add an entry for the Rhino server, pasting the command and args from step 1:
-
-   ```json
-   {
-     "servers": {
-       "rhino": {
-         "command": "rhino-mcp-router",
-         "args": ["--default-version", "8"]
-       }
-     }
-   }
-   ```
-
-4. Reload VS Code. In the Copilot Chat agent-mode tool picker, you should see the `rhino` server and its tools listed.
-
-> **Pick the Rhino version** by changing the `--default-version` arg.
-> Use `8` for Rhino 8, `9` for Rhino 9 WIP/BETA.
-
-## Try it out
-
-<blockquote class="page-note">
-Open Copilot Chat in <strong>Agent</strong> mode and follow the prompts on the <a href="../../try-it-out">Try It Out</a> page.
-</blockquote>

package/mcps/RhinoMCP/docs/content/docs/getting-started/lm-studio.md

@@ -1,62 +0,0 @@
----
-title: Local LLMs
-icon: lmstudio
-weight: 7
-prev: docs/getting-started
-next: docs/try-it-out
-toc: false
-author: Callum
-editor: SteveF
-keywords:
-  - LM Studio
-  - local LLM
-  - open-weight
-  - self-hosted
----
-
-![Local LLM](/local-llm.png)
-
-[LM Studio](https://lmstudio.ai) is a desktop app for running open-weight models on your own machine. It speaks MCP, so once you point it at the Rhino server a local model can drive Rhino the same way a hosted one can.
-
-If you're choosing between assistants and aren't sure, start with [Claude Desktop](../connector); it's the gentler entry point. Pick LM Studio when you'd rather keep everything on your own hardware or have data and privacy concerns.
-
-{{< callout type="warning" >}}
-Local open-weight models are not as capable as the paid hosted models (Claude, GPT, etc.). Expect more retries, weaker reasoning on long chains of tool calls, and the occasional refusal to use tools at all.
-{{< /callout >}}
-
-## 1. Install LM Studio
-
-1. Install [LM Studio](https://lmstudio.ai), then download a model with strong tool-use support. A good starting point is [Qwen3](https://lmstudio.ai/models/qwen3), which drives MCP tools reliably. Plan on **16 GB of RAM** as a minimum.
-2. **Crank up the context length.** LM Studio defaults to a small context window, which the Rhino tool list alone will blow through. Open the model's load settings and push the max context length as high as your machine will allow.
-
-## 2. Install the Rhino plugin
-
-{{< yak package="Rhino-MCP-Platform" version="8" >}}
-{{< yak package="Rhino-MCP-Platform" version="9" >}}
-
-If that doesn't work you can try the below:
-
-1. Open Rhino 8 (and/or Rhino 9 WIP)
-2. Run the `PackageManager` command
-3. Search for, and install Rhino-MCP-Platform
-
-## 3. Wire up the Rhino server
-
-1. In Rhino, run the `MCPConnect` command, choose the mcp.json tab. It gives the JSON needed for LM Studio to connect to the Rhino MCP.
-2. In LM Studio, open the **Program** sidebar and click **Install &gt; Edit mcp.json** (or open `~/.lmstudio/mcp.json` directly).
-3. Add an entry for the Rhino server, pasting the mcp.json tab.
-4. Save the file. LM Studio picks up the change without a restart; the `rhino` server should appear in the MCP tool list for any new chat.
-
-> **Pick the Rhino version** by changing the `--default-version` arg.
-> Use `8` for Rhino 8, `9` for Rhino 9 WIP/BETA.
-
-## Try it out
-
-<blockquote class="page-note">
-Load your model in LM Studio, start a new chat with tool use enabled, and follow the prompts on the <a href="../../try-it-out">Try It Out</a> page.
-</blockquote>
-
-## Tips
-
-- **Tool use must be on.** In the chat sidebar, make sure the `rhino` server is toggled on for the session. LM Studio defaults to asking before each tool call.
-- **Smaller models struggle.** If the model keeps describing what it would do instead of calling tools, try a larger or more recent instruction-tuned model.