sqlanywhere-mcp

<div align="center">

# sqlanywhere-mcp
##### MCP server for SAP SQL Anywhere 17

<img alt="sqlanywhere-mcp logo" height="192" src="https://raw.githubusercontent.com/Dwarf1er/sqlanywhere-mcp/master/assets/logo.png" />

[![CI](https://img.shields.io/github/actions/workflow/status/Dwarf1er/sqlanywhere-mcp/ci.yml?style=for-the-badge&label=CI)](https://github.com/Dwarf1er/sqlanywhere-mcp/actions/workflows/ci.yml)
[![NuGet](https://img.shields.io/nuget/v/SqlAnywhereMcp?style=for-the-badge)](https://www.nuget.org/packages/SqlAnywhereMcp)
[![Release](https://img.shields.io/github/v/release/Dwarf1er/sqlanywhere-mcp?style=for-the-badge)](https://github.com/Dwarf1er/sqlanywhere-mcp/releases)
[![License](https://img.shields.io/github/license/Dwarf1er/sqlanywhere-mcp?style=for-the-badge)](https://github.com/Dwarf1er/sqlanywhere-mcp/blob/master/LICENSE)

</div>

<!-- mcp-name: io.github.Dwarf1er/sqlanywhere-mcp -->

MCP (*Model Context Protocol*) server for SQL Anywhere 17. Lets an MCP client such as Claude Code or Claude Desktop query a SQL Anywhere database directly to explore the schema, stored procedures, triggers, and views. It runs on Windows, Linux, and macOS.

> **Disclaimer:** sqlanywhere-mcp is an independent, community open-source project. It is not affiliated with, endorsed by, or sponsored by SAP SE. SAP and SQL Anywhere are trademarks or registered trademarks of SAP SE. sqlanywhere-mcp does not include or redistribute any SAP software.

## Table of contents

- [sqlanywhere-mcp](#sqlanywhere-mcp)
  - [Table of contents](#table-of-contents)
  - [Prerequisites](#prerequisites)
    - [ODBC driver setup](#odbc-driver-setup)
  - [Installation](#installation)
    - [From NuGet](#from-nuget)
    - [From a release](#from-a-release)
    - [From source](#from-source)
  - [Configuration](#configuration)
    - [File location](#file-location)
    - [Fields](#fields)
    - [Live reload](#live-reload)
  - [Database password](#database-password)
    - [Suggested helper: keyturn](#suggested-helper-keyturn)
  - [Claude Code integration](#claude-code-integration)
    - [As a plugin](#as-a-plugin)
    - [By hand](#by-hand)
  - [Claude Desktop integration](#claude-desktop-integration)
  - [Multiple databases](#multiple-databases)
  - [Available tools](#available-tools)
    - [Databases](#databases)
    - [Query execution](#query-execution)
    - [Ownership](#ownership)
    - [Schema introspection](#schema-introspection)
    - [Object lists](#object-lists)
    - [Source retrieval](#source-retrieval)
    - [Procedure calls](#procedure-calls)
  - [How it works](#how-it-works)
  - [License](#license)

## Prerequisites

- The **SQL Anywhere 17 ODBC driver**, installed on the machine that runs sqlanywhere-mcp. It comes with the [SQL Anywhere 17](https://www.sap.com/products/data-cloud/sql-anywhere.html) client or server install, for the platform you run on.
- On **Linux and macOS**, an ODBC driver manager: [unixODBC](https://www.unixodbc.org/) (for example `apt install unixodbc`, `dnf install unixODBC`, `brew install unixodbc`). On Windows the driver manager is built in.
- The [.NET 10 SDK](https://dotnet.microsoft.com/download/dotnet/10.0), to build from source.
- An MCP client, such as [Claude Code](https://claude.ai/code) or Claude Desktop.

sqlanywhere-mcp itself is a .NET application with no platform-specific code. What differs per platform is how the driver is registered, which is covered in [ODBC driver setup](#odbc-driver-setup).

### ODBC driver setup

sqlanywhere-mcp connects with the ODBC driver named `SQL Anywhere 17`, which is the name the Windows installer registers. Use the `driver` setting (see [Fields](#fields)) when your driver is registered under another name.

- **Windows:** nothing to do after installing SQL Anywhere 17.
- **Linux and macOS:** unixODBC needs to know the driver. Either register it in `odbcinst.ini` under the name `SQL Anywhere 17`, or set `driver` in `config.json` to the path of the driver library, for example `/opt/sqlanywhere17/lib64/libdbodbc17.so` (the path depends on where SQL Anywhere is installed). The driver also needs its own libraries to be loadable; SQL Anywhere provides an `sa_config.sh` script for that, which you can source before starting your MCP client. See SAP's documentation for the details of your platform.

When the connection fails, the tool error names the driver it used, so a wrong driver name or a missing driver is visible in the client.

## Installation

There are three ways to get sqlanywhere-mcp. All of them give the same server, which needs the [prerequisites](#prerequisites) above (the ODBC driver, plus unixODBC on Linux and macOS).

### From NuGet

The [`SqlAnywhereMcp`](https://www.nuget.org/packages/SqlAnywhereMcp) package is a .NET tool with a self-contained build for each platform (`win-x64`, `linux-x64`, `linux-arm64`, `osx-x64`, `osx-arm64`), so no .NET runtime is needed to run it. It needs the .NET 10 SDK to install, which provides `dnx` and `dotnet tool`.

Run it without installing, which is what MCP clients usually do:

```bash
dnx SqlAnywhereMcp --yes
```

Or install it as a global tool, which puts `sqlanywhere-mcp` on your `PATH`:

```bash
dotnet tool install --global SqlAnywhereMcp
```

To register it with Claude Code without installing anything first:

```bash
claude mcp add --transport stdio --scope user sqlanywhere -- dnx SqlAnywhereMcp --yes
```

### From a release

Each [GitHub release](https://github.com/Dwarf1er/sqlanywhere-mcp/releases) has an archive per platform with the self-contained executable, plus a `SHA256SUMS` file. Unpack the one for your platform somewhere on your `PATH` and verify it with `sha256sum -c SHA256SUMS`. The executables are not code-signed, so macOS Gatekeeper and Windows SmartScreen may warn on first run.

### From source

Run the install script for your platform from a regular user account (no administrator rights needed). Each one publishes a self-contained executable, so the .NET runtime is not needed to run it.

**Windows** (PowerShell):

```powershell
.\install.ps1
```

It publishes `sqlanywhere-mcp.exe` to `%LOCALAPPDATA%\sqlanywhere-mcp\`, adds that directory to the user `PATH`, and prints the command to register the server with Claude Code.

| Option | Description |
|--------|-------------|
| `-Configuration Release` | Build configuration (default: `Release`) |
| `-Configuration Debug` | Build in Debug mode |
| `-Help` | Show help |

**Linux and macOS** (bash):

```bash
./install.sh
```

It detects the platform (`linux-x64`, `linux-arm64`, `osx-x64`, or `osx-arm64`), publishes `sqlanywhere-mcp` to `~/.local/bin/`, and prints the command to register the server with Claude Code. `-c Debug` builds in Debug mode.

The driver must match the architecture of the executable. If your SQL Anywhere 17 driver is x64 only, use an x64 build (on Apple silicon, the x64 build runs under Rosetta).

**Any platform**, by hand:

```bash
dotnet publish src/SqlAnywhereMcp -c Release -r <rid> --self-contained -o <output-dir>
```

where `<rid>` is a [.NET runtime identifier](https://learn.microsoft.com/dotnet/core/rid-catalog) such as `win-x64`, `linux-x64`, or `osx-x64`.

## Configuration

### File location

| Platform | Path |
|----------|------|
| Windows | `%APPDATA%\sqlanywhere-mcp\config.json` |
| Linux / macOS | `$XDG_CONFIG_HOME/sqlanywhere-mcp/config.json`, or `~/.config/sqlanywhere-mcp/config.json` when `XDG_CONFIG_HOME` is not set |

If the file is missing on first launch, an example is created automatically. Edit it and restart sqlanywhere-mcp once; after that, changes are picked up without a restart (see [Live reload](#live-reload)).

**Example configuration:**

```json
{
  "defaults": {
    "username": "dba",
    "passwordCommand": "keyturn get dev-db --refresh"
  },
  "allowedProcedures": [],
  "defaultDatabase": "demo",
  "databases": {
    "demo": { "host": "localhost", "database": "demodb" },
    "staging": {
      "host": "db.example.com",
      "port": 2700,
      "database": "stagingdb",
      "passwordCommand": "keyturn get staging-db --refresh",
      "allowedProcedures": ["dbo.sa_conn_info"]
    }
  }
}
```

Unknown fields are rejected, so a misspelled field (for example `allowedProcedure`) is reported instead of being silently ignored.

### Fields

Top level:

| Field | Required | Description |
|-------|----------|-------------|
| `databases` | Yes | The databases tools can reach, keyed by name. The name is what tools take as their `database` argument, and must be unique ignoring case. An empty object is valid: tools then report that no database is configured. See the fields below |
| `defaults` | No | Values every database uses unless it sets its own. See the fields below |
| `defaultDatabase` | No | Name of the database a tool uses when called without `database`. Not needed with a single database |
| `allowedProcedures` | No | Stored procedures that `call_procedure` may call on every database, each written as `owner.procedure` (default: none). See [Procedure calls](#procedure-calls) |

`defaults`:

| Field | Default | Description |
|-------|---------|-------------|
| `username` | - | Login username. Required, here or on each database |
| `passwordCommand` | - | Credential helper: a command that prints the database password. Required, here or on each database. See [Database password](#database-password) |
| `appInfo` | - | Value of the `AppInfo` ODBC parameter, used by SQL Anywhere to identify the connecting application (for example `my-app`) |
| `driver` | `SQL Anywhere 17` | ODBC driver name as registered with the driver manager, or the path of the driver library. See [ODBC driver setup](#odbc-driver-setup) |
| `port` | `2638` | TCP port of the database (SQL Anywhere's standard port) |

Each database:

| Field | Required | Description |
|-------|----------|-------------|
| `host` | Yes | Hostname of the SQL Anywhere server |
| `database` | Yes | Database name (`DBN` ODBC parameter) |
| `port` | No | Overrides `defau