# AdoMcp

**Category:** 🗄️ Databases  
**Repository:** https://github.com/John0King/AdoMCP  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/adomcp

## Description
Database MCP server for schema discovery, comments, and SQL queries.

## Claude Desktop Quick Installation
Heuristic fallback — verify the package name and runner against the repository README before running it. Uses `npx` (confidence: low):

```json
"mcpServers": {
  "adomcp": {
    "command": "npx",
    "args": ["-y","adomcp"]
  }
}
```

## Documentation & README

# AdoMcp

[![NuGet](https://img.shields.io/nuget/v/AdoMcp.svg)](https://www.nuget.org/packages/AdoMcp)

**AdoMcp** is a [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that helps large language models (LLMs) understand database structure, read table comments, and execute SQL queries.

AdoMcp 是一个基于 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) 的数据库工具服务，帮助大型语言模型（LLM）理解数据库结构、读取表注释、执行 SQL 查询。

<!-- mcp-name: io.github.John0King/adomcp -->

## MCP Tools

| Tool | Description |
|---|---|
| `list_connections` | List configured database connections |
| `add_connection` | Add (or replace) a database connection at runtime |
| `remove_connection` | Remove a dynamically-added connection |
| `list_objects` | List database objects (table/view/procedure/function/trigger/sequence/synonym, etc.) |
| `get_table_schema` | Get table schema details (columns/types/nullability/PK/default/comments) |
| `get_table_indexes` | Get table indexes |
| `query_sql` | Execute read-only SQL and return CSV |
| `execute_sql` | Execute write SQL (requires `--allow-any-sql`) |

## Recommended Tool Workflow (for LLM agents)

To reduce mistakes (wrong database/schema/object), use tools in this order:

1. `list_connections` to discover available connections.
2. If none are available, call `add_connection`.
3. Before inspecting a table/view, call `list_objects` to locate `schema + objectType + objectName`.
4. Use `get_table_schema` for column details (type, nullability, PK, default, comments).
5. Use `get_table_indexes` when index/key design matters.
6. Use `query_sql` only for read-only verification.
7. Use `execute_sql` only when explicitly authorized and server is started with `--allow-any-sql`.

Oracle note: objects without owner prefix may be synonyms. Always confirm the real schema via `list_objects` first.

## Supported Databases

| Database | Driver | Comment support |
|---|---|---|
| **SQL Server** | `Microsoft.Data.SqlClient` | `MS_Description` extended properties |
| **MySQL / MariaDB** | `MySqlConnector` | `TABLE_COMMENT` / `COLUMN_COMMENT` |
| **PostgreSQL** | `Npgsql` | `obj_description` / `col_description` |
| **SQLite** | `Microsoft.Data.Sqlite` | — (SQLite has no native comments) |
| **Oracle** | `Oracle.ManagedDataAccess.Core` | `ALL_TAB_COMMENTS` / `ALL_COL_COMMENTS` (includes PUBLIC synonyms) |

ORM support: [Dapper](https://github.com/DapperLib/Dapper)

## Requirements

- [.NET 10 SDK](https://dotnet.microsoft.com/download/dotnet/10.0)

---

## Quick Start

### 1. Configure database connections (optional)

AdoMcp loads configuration from multiple sources (later sources override earlier ones):

1. `appsettings.json` (in the app directory)
2. `appsettings.{Environment}.json`
3. **`~/.adomcp.json`** — user-level config (`%USERPROFILE%\.adomcp.json` on Windows), persists connections and `AllowAnySql` without touching the app directory
4. Environment variables prefixed `ADOMCP_`
5. [.NET User Secrets](https://learn.microsoft.com/aspnet/core/security/app-secrets)

You can pre-configure connections in any of these. You can also skip this step entirely and let the LLM add connections dynamically via the `add_connection` tool.

```json
{
  "AllowAnySql": false,
  "Databases": [
    {
      "Name": "mydb",
      "DbType": "SqlServer",
      "ConnectionString": "Server=localhost;Database=MyDb;User Id=sa;Password=***;TrustServerCertificate=true;",
      "Description": "Main business database"
    }
  ]
}
```

Supported `DbType` values: `SqlServer` | `MySql` | `PostgreSql` | `Sqlite` | `Oracle`

> **Security tip**: Use [.NET User Secrets](https://learn.microsoft.com/aspnet/core/security/app-secrets) or environment variables to manage connection strings in production.

#### User-level config example (`~/.adomcp.json`)

Create `~/.adomcp.json` in your home directory to persist personal connections and settings across projects:

```json
{
  "AllowAnySql": true,
  "Databases": [
    {
      "Name": "local-pg",
      "DbType": "PostgreSql",
      "ConnectionString": "Host=localhost;Database=dev;Username=postgres;Password=***;",
      "Description": "Local PostgreSQL dev DB"
    }
  ]
}
```

### 2. Run the server

#### Default mode

By default the server runs in **stdio** mode (the standard MCP transport for local clients).
Use `--http` (or `ADOMCP_MODE=http`) to switch to **HTTP/SSE** mode.

```bash
# stdio mode (default) - all logs go to stderr; stdout carries only MCP JSON-RPC
dnx -y AdoMcp
```

#### Specify mode manually

```bash
# stdio mode (all logs go to stderr; stdout carries only MCP JSON-RPC)
dnx -y AdoMcp -- --stdio

# HTTP/SSE mode (default: http://localhost:5100, MCP endpoint /mcp)
dnx -y AdoMcp -- --http

# Via environment variable
ADOMCP_MODE=http 
dnx -y AdoMcp
```

#### Enable execute_sql (write operations)

By default the `execute_sql` tool is **disabled** to prevent unauthorised writes.  
Enable it via CLI flag, config file, or environment variable (CLI flag wins when explicitly set):

```bash
# CLI flag
# Combine with transport mode
dnx -y AdoMcp -- --http --allow-any-sql
```

```jsonc
// ~/.adomcp.json or appsettings.json
{
  "AllowAnySql": true
}
```

```bash
# Environment variable
# ADOMCP_ALLOWANYSQL=true dnx -y AdoMcp
```

Priority: `--allow-any-sql` CLI > `ADOMCP_ALLOWANYSQL` env > `~/.adomcp.json` `AllowAnySql` > `appsettings.json` `AllowAnySql` > `false` (default).

### 3. Alternative: Install as a global .NET tool

After the package is published to NuGet.org, you can also install it as a global tool:

```bash
dotnet tool install -g AdoMcp
adomcp
```

You can also run dnx directly (installs and runs on demand, .NET 10+):

```bash
dnx -y AdoMcp -- --allow-any-sql
```

---

## Dynamic connections at runtime (no config file needed)

LLMs can add new database connections during a session using `add_connection`:

```
User: Connect me to Oracle database oradb01
LLM → calls add_connection(
    connectionString = "Data Source=oradb01:1521/PROD;User Id=appuser;Password=***;",
    dbType = "Oracle",
    name = "prod-oracle",
    description = "Production Oracle DB"
)
→ returns: Connection 'prod-oracle' (Oracle) added successfully.
LLM → calls list_objects(connectionName = "prod-oracle")
```

Dynamically-added connections exist only for the lifetime of the process; restart the server or add the connection to `appsettings.json` for persistence.

---

## Client configuration

### Via dnx (stdio)

```json
{
  "mcpServers": {
    "adomcp": {
      "command": "dnx",
      "args": ["-y", "AdoMcp"]
    }
  }
}
```

### Via HTTP/SSE

Start the server first:
```bash
dnx -y AdoMcp -- --http
```

Then configure the client:
```json
{
  "mcpServers": {
    "adomcp": {
      "url": "http://localhost:5100/mcp"
    }
  }
}
```

---

## Environment variables

All environment variables are prefixed with `ADOMCP_` (override `appsettings.json`):

| Variable | Description |
|---|---|
| `ADOMCP_MODE` | Transport mode: `stdio` or `http` (auto-detected when not set) |
| `ADOMCP_URLS` | HTTP listen address, e.g. `http://0.0.0.0:5100` |
| `ADOMCP_ALLOWANYSQL` | Enable the `execute_sql` tool: `true` or `false` (default `false`) |
| `ADOMCP_DATABASES` | JSON-encoded `Databases` array (overrides config-file connections) |

---

## MCP Registries

AdoMcp is registered in the official [MCP Registry](https://registry.modelcontextprotocol.io/) under the server name `io.github.John0King/adomcp`.