# Inovacc MCP

The [Model Context Protocol](https://modelcontextprotocol.io) (MCP) is an open standard that lets AI assistants call tools exposed by a server. The Inovacc MCP server is a program, `inovacc mcp serve`, that runs on your machine with this documentation built in, so your assistant can look up Inovacc products, endpoints and guides and answer with their sources.

It works with any MCP-compatible client, including Cursor, Claude Code, VS Code (GitHub Copilot), Windsurf, Cline, Claude Desktop, JetBrains IDEs, Codex CLI and Gemini CLI.

To let your agent do the whole setup itself, give it this line:

```text
Fetch and execute the appropriate instructions to set me up for Inovacc from https://developer.inovacc.dev/agent-setup/prompt.md
```

## Capabilities

With the server connected, your assistant can:

- search the documentation: contract sections, products, guides and quickstarts
- explore endpoints: the contract section for any method and path, such as `POST /v1/vector/query`
- get a quickstart for a product: base URL, headers and a curl skeleton
- tell you which documentation version it is answering from

It does not execute requests and does not touch your account. The server is read-only, needs no API key, and answers from the documentation embedded in the program.

## Prerequisites

- Windows on x86_64. macOS and Linux are coming; there is no date yet.
- An MCP-compatible client from the list below.
- The release files for the `inovacc` program. The repository is private until launch: download the release your Inovacc contact shares with you.

## Install the inovacc CLI

1. Download `inovacc-windows-x86_64.exe` and `inovacc-windows-x86_64.exe.sha256` from the release.
2. Check the download in PowerShell. The two values must be identical:

```powershell
(Get-FileHash .\inovacc-windows-x86_64.exe -Algorithm SHA256).Hash.ToLower()
Get-Content .\inovacc-windows-x86_64.exe.sha256
```

3. Rename the file to `inovacc.exe` and put it in a folder on your `PATH`.
4. Open a new terminal and verify:

```powershell
inovacc docs version
```

The output has this shape; the version numbers differ by release:

```text
embedded   2026.10.09-0
installed  none
active     embedded 2026.10.09-0
previous   none
published  unknown; run `inovacc docs update --check`
data dir   C:\Users\<you>\AppData\Local\Inovacc\knowledge
```

## Connect your editor or chat app

Every client needs the same three facts: the transport is stdio, the command is `inovacc`, and the arguments are `mcp` and `serve`. Restart the client after changing its configuration.

### Cursor

Create `.cursor/mcp.json` in a project, or `~/.cursor/mcp.json` for every project:

```json
{
  "mcpServers": {
    "inovacc": {
      "command": "inovacc",
      "args": ["mcp", "serve"]
    }
  }
}
```

### Claude Code

```sh
claude mcp add inovacc -- inovacc mcp serve
```

The `--` separates Claude's own options from the command that runs the server. By default the server is added in the `local` scope: available only to you, in the current project. Choose another scope with `-s` before the name:

```sh
claude mcp add -s project inovacc -- inovacc mcp serve
claude mcp add -s user inovacc -- inovacc mcp serve
```

`project` writes `.mcp.json` in the project root, shared with everyone who uses the repository. `user` makes the server available in all your projects.

### VS Code (GitHub Copilot)

Create `.vscode/mcp.json` in a workspace, or run **MCP: Open User Configuration** for your user profile:

```json
{
  "servers": {
    "inovacc": {
      "type": "stdio",
      "command": "inovacc",
      "args": ["mcp", "serve"]
    }
  }
}
```

**Important:** `.vscode/mcp.json` uses `servers`, not `mcpServers`. VS Code's own documentation sets `"type": "stdio"` in its stdio examples, so this page does too. A project-root `.mcp.json` uses `mcpServers`, like the other clients.

### Windsurf

Windsurf's documentation now lives with Devin Desktop. Add the server to `mcp_config.json`, at `%APPDATA%\devin\mcp_config.json` on Windows:

```json
{
  "mcpServers": {
    "inovacc": {
      "command": "inovacc",
      "args": ["mcp", "serve"]
    }
  }
}
```

### Cline

In the Cline panel, click the MCP Servers icon in the top toolbar, open the Configure tab and click **Configure MCP Servers**. Add the server to the settings file that opens (`cline_mcp_settings.json`):

```json
{
  "mcpServers": {
    "inovacc": {
      "command": "inovacc",
      "args": ["mcp", "serve"]
    }
  }
}
```

### Claude Desktop

Open the Claude menu, then **Settings**, the **Developer** tab and **Edit Config**. The file is `%APPDATA%\Claude\claude_desktop_config.json` on Windows:

```json
{
  "mcpServers": {
    "inovacc": {
      "command": "inovacc",
      "args": ["mcp", "serve"]
    }
  }
}
```

Quit Claude Desktop completely and start it again. If the app cannot find `inovacc`, give the full path to `inovacc.exe` as the command, with each backslash doubled in JSON.

### JetBrains IDEs

Open **Settings | Tools | AI Assistant | Model Context Protocol (MCP)**, click **Add**, choose the **STDIO** connection type and enter:

```json
{
  "mcpServers": {
    "inovacc": {
      "command": "inovacc",
      "args": ["mcp", "serve"]
    }
  }
}
```

Click **OK**, then **Apply**.

### Codex CLI

```sh
codex mcp add inovacc -- inovacc mcp serve
```

or write it in `~/.codex/config.toml` (a trusted project can use `.codex/config.toml`):

```toml
[mcp_servers.inovacc]
command = "inovacc"
args = ["mcp", "serve"]
```

**Important:** Codex uses TOML and `mcp_servers`, not JSON and `mcpServers`.

### Gemini CLI

```sh
gemini mcp add inovacc inovacc mcp serve
```

or add the server to `~/.gemini/settings.json` (a project can use `.gemini/settings.json`):

```json
{
  "mcpServers": {
    "inovacc": {
      "command": "inovacc",
      "args": ["mcp", "serve"]
    }
  }
}
```

### Any other client

Use the stdio transport with the command `inovacc` and the arguments `mcp` and `serve`. Check your client's MCP documentation for where that goes.

## Verify your setup

Ask your assistant: "What does POST /v1/vector/query take?" A working setup answers from the contract and names the document it came from and the knowledge version.

Without an assistant, search from the terminal:

```sh
inovacc docs search "vector query"
```

Each hit shows the document id, its title and its citation (repository, path and source commit).

## Troubleshooting

- **`inovacc` is not found.** The folder holding `inovacc.exe` is not on your `PATH`, or the terminal was opened before you changed it. Open a new terminal. In the client's configuration you can give the full path to `inovacc.exe` as the command.
- **The client does not list the server.** Restart the client completely, then check that the command in its configuration runs in a terminal: `inovacc mcp serve` should wait silently for input (press Ctrl+C to leave).
- **Answers look old.** Run `inovacc docs version` to see what is in use and what is published, then `inovacc docs update`.
- **Windows SmartScreen warns on first run.** The program is not code-signed today, so Windows may show "Windows protected your PC". Check the checksum as described above before you choose to run it.

## Available MCP tools

| Tool | What it does |
|---|---|
| `search_documentation` | Full-text search over contract sections, capabilities, quickstarts and guides |
| `get_document` | One document in full, by id, with its provenance |
| `get_api_reference` | The contract section for one endpoint, such as `POST /v1/vector/query` |
| `list_products` | The products and capabilities with documentation, and how many documents each has |
| `get_quickstart` | Base URL, endpoints, scopes, the headers every call needs and a curl skeleton |
| `get_knowledge_version` | Which documentation bundle is answering: version, build time, pinned commits and document count |

## Keep the documentation current

The program carries the documentation it was built with and can install newer, signed documentation without a new program.

```sh
inovacc docs version      # embedded, installed, active, previous and published versions
inovacc docs update       # download, verify and install the newest published documentation
inovacc docs update --check
inovacc docs rollback     # go back to the previous installed documentation
```

- Documentation is published as signed bundles. A bundle is installed only if its size, SHA-256 and Ed25519 signature check out, and a bundle that is not newer than the one in use is refused, so a downgrade cannot be forced.
- The automatic check runs at most once every 24 hours, never delays an answer, installs nothing and at most prints one line telling you a newer version exists.
- Until launch, updates reach you through the release your Inovacc contact shares with you.

## Configuration reference

| Setting | What it does |
|---|---|
| `INOVACC_KNOWLEDGE_DIR` | The folder where installed documentation is kept. Default on Windows: `%LOCALAPPDATA%\Inovacc\knowledge` |
| `INOVACC_NO_UPDATE_CHECK` | Set to `1` to turn off the automatic check for newer documentation. The flag `--no-update-check` does the same for one run |
| `INOVACC_UPDATE_URL` | The address of `latest.json` that updates are read from; it must be HTTPS |

## FAQ

**Do I need an API key?**
No. The server reads documentation only and never uses your account.

**Does it send my questions anywhere?**
No. Questions are answered on your machine. The only network use is the automatic check for newer documentation, at most once a day, which you can turn off.

**Can my assistant call the Inovacc API through it?**
No. It tells the assistant how an endpoint works and how to call it; it does not make the call.

**Is there a hosted MCP server?**
A remote server at `https://mcp.inovacc.dev` is planned. It does not exist yet.

**Which platforms are supported?**
Windows x86_64 today. macOS and Linux are coming, with no date yet.

## See also

- [Authentication](/en/guides/authentication/): the headers every API call carries.
- [API reference](/en/reference/): every product and its endpoints.
- [llms.txt](/llms.txt): the same documentation as an index for language models.
