Mcp Firebird

by PuroDelphi

3.5k downloads Not rated yet

GitHub

About

MCP Firebird is a server that implements Anthropic's Model Context Protocol (MCP) for Firebird SQL databases. It allows Large Language Models (LLMs) like Claude to access, analyze, and manipulate data in Firebird databases securely and in a controlled manner.

Explore

The MCP Firebird server offers:

- Databases: List of all available databases
- Tables: List of all tables in the database
- Views: List of all views in the database
- Stored procedures: Access to procedures in the database
- Table schemas: Detailed structure of each table
- Data: Access to table data

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Mcp Firebird

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

From the repository

npm install -g mcp-firebird

npm install mcp-firebird

You can configure the server using environment variables:

export FIREBIRD_HOST=localhost export FIREBIRD_PORT=3050 export FIREBIRD_DATABASE=/path/to/database.fdb export FIREBIRD_USER=SYSDBA export FIREBIRD_PASSWORD=masterkey export FIREBIRD_ROLE=undefined # Optional

export FIREBIRD_DATABASE_DIR=/path/to/databases # Directory with databases

To use the Firebird MCP server with Claude Desktop:

    code ~/Library/Application\ Support/Claude/claude_desktop_config.json

</Tab>
<Tab title="Windows">

    code $env:AppData\Claude\claude_desktop_config.json

</Tab>
</Tabs>

Add the following configuration:

{
  "mcpServers": {
    "mcp-firebird": {
      "command": "npx",
      "args": [
        "mcp-firebird",
        "--host",
        "localhost",
        "--port",
        "3050",
        "--database",
        "C:\\Databases\\example.fdb",
        "--user",
        "SYSDBA",
        "--password",
        "masterkey"
      ]
    }
  }
}

<Warning>
Make sure to use absolute paths in the configuration.
</Warning>

<Note>
After saving the file, you need to restart Claude Desktop completely.
</Note>

client = McpFirebirdClient('/path/to/database.fdb')
try:

You can run the MCP Firebird server in a Docker container:

RUN apk add --no-cache firebird-client

ENV FIREBIRD_HOST=firebird-db
ENV FIREBIRD_PORT=3050
ENV FIREBIRD_USER=SYSDBA
ENV FIREBIRD_PASSWORD=masterkey
ENV FIREBIRD_DATABASE=/firebird/data/database.fdb

Interaction with Claude:

User: Connect to my Firebird database and analyze sales trends by region in the last quarter.

Claude: I'll connect to your Firebird database to analyze regional sales trends.

[Claude uses MCP Firebird to execute several SQL queries]

Based on data from the last quarter, I've identified the following trends:

1. The North region has experienced 12.5% growth compared to the previous quarter
2. The South region shows a 3.2% decrease in electronics products
3. The "Laptop Pro X" product is the best-selling across all regions
4. Sales in the East region show a cyclical pattern with peaks on weekends

Graphically, the distribution of sales by region is:
[Graph generated by Claude based on the data]

Would you like to delve deeper into any specific region or product category?

Security is a priority in MCP Firebird. Below are advanced options to control access and permitted operations.

javascript
// config-development.js
module.exports = {
database: process.env.FIREBIRD_DATABASE_DEV,
user: process.env.FIREBIRD_USER_DEV,
password: process.env.FIREBIRD_PASSWORD_DEV,

security: {
// In development, allow more operations
allowedOperations: ['SELECT', 'INSERT', 'UPDATE', 'DELETE', 'CREATE'],

// Exclude only critical tables
forbiddenTables: ['SYSTEM_CONFIG', 'APP_SECRETS'],

// Limit impact of heavy queries
resourceLimits: {
maxRowsPerQuery: 1000,
maxQueryCpuTime: 3000,
queriesPerMinute: 120
},

// Basic auditing
audit: {
enabled: true,
destination: 'file',
auditFile: './logs/dev-audit.log',
detailLevel: 'basic'
}
}
};
```

These examples illustrate how MCP Firebird can be configured for different use cases, each with its own security and data access considerations.

`execute-query`

Executes a SQL query in the Firebird database. Uses FIRST/ROWS for pagination.

`list-tables`

Lists all user tables in the current Firebird database.

`describe-table`

Gets the detailed schema (columns, types, etc.) of a specific table.

`get-field-descriptions`

Gets the stored descriptions for fields of a specific table (if they exist).

`analyze-query-performance`

Analyzes the performance of a SQL query by executing it multiple times and measuring execution time

`get-execution-plan`

Gets the execution plan for a SQL query to understand how the database will execute it

`analyze-missing-indexes`

Analyzes a SQL query to identify missing indexes that could improve performance

`execute-batch-queries`

Executes multiple SQL queries in parallel for improved performance.

`describe-batch-tables`

Gets the detailed schema of multiple tables in parallel for improved performance.

`get-table-data`

Retrieves data from a specific table with optional filtering, pagination, and ordering.

`analyze-table-statistics`

Analyzes statistical information about a table including row count, column statistics, and data distribution.

`verify-wire-encryption`

Verifies if the current database connection is using wire encryption (requires native driver).

`get-database-info`

Retrieves general information about the connected Firebird database.

`get-server-info`

Gets information about the Firebird MCP server and its available tools

`list-available-tools`

Lists all tools available on the MCP server

`get-tool-help`

Gets detailed information about a specific tool

`system-health-check`

Checks system health and database connectivity

`list-available-events`

Lists native events (POST_EVENT) available in database triggers and procedures

`list-triggers`

Lists all database triggers with their associated table, trigger type, and status

`describe-trigger`

Gets detailed information about a specific trigger, including its source code, type, sequence, and status

`list-procedures`

Lists all stored procedures in the database with input and output parameter information

`describe-procedure`

Gets detailed information about a specific stored procedure, including its source code and parameters

`list-functions`

Lists all functions in the database (UDFs and PSQL functions)

`describe-function`

Gets detailed information about a specific function, including its source code (for PSQL functions)

`list-packages`

Lists all packages in the database (available in Firebird 3.0+)

`describe-package`

Gets detailed information about a specific package, including its header and body source

`subscribe_to_event`

Subscribe to a Firebird event (POST_EVENT) to receive proactive notifications

1. list-tables: Lists all tables in the database

   {}  // No parameters required

2. describe-table: Describes the structure of a table

   {

     "tableName": "EMPLOYEES"

   }

3. execute-query: Executes an SQL query in the database

   {

     "sql": "SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID = 10",

     "params": []  // Optional parameters for prepared queries

   }

4. get-field-descriptions: Gets field descriptions

   {

     "tableName": "EMPLOYEES"

   }

The get-field-descriptions tool is especially useful for AI models, as it retrieves comments from Firebird's RDB$DESCRIPTION metadata, providing additional semantic context about the purpose of each field.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "mcp firebird": {
            "mcp-firebird": {
                "command": "npx",
                "type": "stdio",
                "args": [
                    "mcp-firebird",
                    "--host",
                    "localhost",
                    "--port",
                    "3050",
                    "--database",
                    "C:\\Databases\\example.fdb",
                    "--user",
                    "SYSDBA",
                    "--password",
                    "masterkey"
                ]
            }
        }
    }
}

McpServers

{
    "mcp-firebird": {
        "command": "npx",
        "type": "stdio",
        "args": [
            "mcp-firebird",
            "--host",
            "localhost",
            "--port",
            "3050",
            "--database",
            "C:\\Databases\\example.fdb",
            "--user",
            "SYSDBA",
            "--password",
            "masterkey"
        ]
    }
}

Implementation of Anthropic's MCP protocol for Firebird databases.

What is MCP Firebird and what is it for?

You'll find use cases and examples below.

Installation

```bash

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Explore

Setting up with Highlight

From the repository

execute-query

list-tables

describe-table

get-field-descriptions

analyze-query-performance

get-execution-plan

analyze-missing-indexes

execute-batch-queries

describe-batch-tables

get-table-data

analyze-table-statistics

verify-wire-encryption

get-database-info

get-server-info

list-available-tools

get-tool-help

system-health-check

list-available-events

list-triggers

describe-trigger

list-procedures

describe-procedure

list-functions

describe-function

list-packages

describe-package

subscribe_to_event

Claude Desktop / Cursor

McpServers

What is MCP Firebird and what is it for?

Installation

More like this

Sequential Thinking

Redis

Filesystem

EverArt

`execute-query`

`list-tables`

`describe-table`

`get-field-descriptions`

`analyze-query-performance`

`get-execution-plan`

`analyze-missing-indexes`

`execute-batch-queries`

`describe-batch-tables`

`get-table-data`

`analyze-table-statistics`

`verify-wire-encryption`

`get-database-info`

`get-server-info`

`list-available-tools`

`get-tool-help`

`system-health-check`

`list-available-events`

`list-triggers`

`describe-trigger`

`list-procedures`

`describe-procedure`

`list-functions`

`describe-function`

`list-packages`

`describe-package`

`subscribe_to_event`