MCP Firebird

为 Firebird 数据库实现的 Anthropic MCP 协议。

什么是 MCP Firebird，它有什么用？

MCP Firebird 是一个服务器，它为 Firebird SQL 数据库 实现了 Anthropic 的 模型上下文协议 (MCP)。它允许像 Claude 这样的大型语言模型 (LLM) 以安全和受控的方式访问、分析和操作 Firebird 数据库中的数据。

您将在下面找到用例和示例。

安装

通过 Smithery 安装

要通过 Smithery 为 Claude Desktop 自动安装 MCP Firebird，请执行以下操作：

npx -y @smithery/cli install @PuroDelphi/mcpFirebird --client claude

手动安装

# 全局安装
npm install -g mcp-firebird

# 项目安装
npm install mcp-firebird

配置

环境变量

您可以使用环境变量配置服务器：

# 基本配置
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  # 可选

# 目录配置（替代方案）
export FIREBIRD_DATABASE_DIR=/path/to/databases  # 包含数据库的目录

# 日志配置
export LOG_LEVEL=info  # 选项：debug, info, warn, error

您可以在项目根目录中创建一个 .env 文件来设置这些变量。提供了一个 .env.example 文件作为模板。

.env 文件示例

FIREBIRD_HOST=localhost
FIREBIRD_PORT=3050
FIREBIRD_DATABASE=F:\Proyectos\SAI\EMPLOYEE.FDB
FIREBIRD_USER=SYSDBA
FIREBIRD_PASSWORD=masterkey
LOG_LEVEL=info

使用 npx

您可以使用 npx 直接运行服务器：

npx mcp-firebird --host localhost --port 3050 --database /path/to/database.fdb --user SYSDBA --password masterkey

使用 SSE（服务器发送事件）传输

MCP Firebird 服务器还支持 SSE 传输，允许客户端通过 HTTP 连接：

# 在您的 .env 文件中将传输类型设置为 SSE
TRANSPORT_TYPE=sse
SSE_PORT=3003

# 使用 SSE 传输运行服务器
npm run sse

然后，您可以使用 MCP Inspector 连接到服务器：

npx @modelcontextprotocol/inspector http://localhost:3003

或者使用提供的脚本：

npm run inspector-sse

SSE 客户端示例

我们提供了几个示例客户端，演示如何使用 SSE 连接到 MCP Firebird 服务器：

• HTML/JavaScript: 请参阅 examples/sse-client.html 获取基于浏览器的客户端
• Node.js: 请参阅 examples/sse-client.js 获取 Node.js 客户端
• Python: 请参阅 examples/sse_client.py 获取 Python 客户端

有关使用 SSE 传输的详细文档，请参阅 docs/sse-examples.md。

使用 Claude Desktop 进行配置

要将 Firebird MCP 服务器与 Claude Desktop 一起使用，请执行以下操作：

<Tabs> <Tab title="MacOS/Linux"> bash code ~/Library/Application\ Support/Claude/claude_desktop_config.json </Tab> <Tab title="Windows"> powershell code $env:AppData\Claude\claude_desktop_config.json </Tab> </Tabs>

添加以下配置：

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

<Warning> 请确保在配置中使用绝对路径。 </Warning>

<Note> "type": "stdio" 参数非常重要，因为它指定了 Claude Desktop 和 MCP 服务器之间的通信方法。这应与服务器配置中的 TRANSPORT_TYPE 设置相匹配。 </Note>

<Note> 保存文件后，您需要完全重启 Claude Desktop。 </Note>

资源和功能

MCP Firebird 服务器提供：

• 数据库: 所有可用数据库的列表
• 表: 数据库中所有表的列表
• 视图: 数据库中所有视图的列表
• 存储过程: 访问数据库中的过程
• 表模式: 每个表的详细结构
• 数据: 访问表数据
• 性能分析: 分析查询执行时间和性能指标
• 执行计划分析: 获取和分析 SQL 执行计划
• 索引建议: 识别可能提高性能的缺失索引
• 数据库备份和恢复: 创建和恢复数据库备份
• 数据库验证: 检查数据库完整性并修复错误
• 增强的安全选项: 数据脱敏、审计日志和资源限制

可用工具

1. list-tables: 列出数据库中的所有表

   {}  // 不需要参数
   

2. describe-table: 描述表的结构

   {
     "tableName": "EMPLOYEES"
   }
   

3. execute-query: 在数据库中执行 SQL 查询

   {
     "sql": "SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID = 10",
     "params": []  // 预处理查询的可选参数
   }
   

4. get-field-descriptions: 获取字段描述

   {
     "tableName": "EMPLOYEES"
   }
   

5. analyze-query-performance: 分析 SQL 查询的性能

   {
     "sql": "SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID = 10",
     "params": [],  // 预处理查询的可选参数
     "iterations": 3  // 用于平均的可选迭代次数（默认值：3）
   }
   

6. get-execution-plan: 获取 SQL 查询的执行计划

   {
     "sql": "SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID = 10",
     "params": []  // 预处理查询的可选参数
   }
   

7. analyze-missing-indexes: 分析 SQL 查询以识别缺失的索引

   {
     "sql": "SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID = 10"
   }
   

8. backup-database: 创建 Firebird 数据库的备份

   {
     "backupPath": "C:\\backups\\mydb_backup.fbk",
     "options": {
       "format": "gbak",  // "gbak"（完整备份）或 "nbackup"（增量备份）
       "compress": true,  // 是否压缩备份
       "metadata_only": false,  // 是否仅备份元数据（不备份数据）
       "verbose": true  // 是否显示详细进度
     }
   }
   

9. restore-database: 从备份恢复 Firebird 数据库

   {
     "backupPath": "C:\\backups\\mydb_backup.fbk",
     "targetPath": "C:\\databases\\restored_db.fdb",
     "options": {
       "replace": true,  // 如果目标数据库存在，是否替换它
       "pageSize": 4096,  // 恢复的数据库的页面大小
       "verbose": true  // 是否显示详细进度
     }
   }
   

10. validate-database: 验证 Firebird 数据库的完整性

    {
      "options": {
        "checkData": true,  // 是否验证数据完整性
        "checkIndexes": true,  // 是否验证索引
        "fixErrors": false,  // 是否尝试修复错误
        "verbose": true  // 是否显示详细进度
      }
    }
    

get-field-descriptions 工具对于 AI 模型尤其有用，因为它从 Firebird 的 RDB$DESCRIPTION 元数据中检索注释，从而提供有关每个字段用途的更多语义上下文。

性能分析工具（analyze-query-performance、get-execution-plan 和 analyze-missing-indexes）通过提供对执行时间、执行计划和索引建议的见解来帮助优化数据库查询。

数据库管理工具（backup-database、restore-database 和 validate-database）提供数据库维护和灾难恢复的功能。

可用提示

1. query-data: 使用自然语言查询数据

   查找 2023 年在销售部门工作的所有员工
   

2. analyze-table: 分析表的结构

   分析 EMPLOYEES 表并解释其结构
   

3. optimize-query: 优化 SQL 查询

   优化：SELECT * FROM EMPLOYEES WHERE LAST_NAME = 'Smith'
   

4. generate-sql: 从描述生成 SQL

   生成一个查询以获取 10 种最畅销的产品
   

从不同语言中使用

TypeScript/JavaScript

// TypeScript 示例
import { McpClient, ChildProcessTransport } from '@modelcontextprotocol/sdk';
import { spawn } from 'child_process';

async function main() {
  // 启动 MCP 服务器进程
  const serverProcess = spawn('npx', [
    'mcp-firebird',
    '--database', '/path/to/database.fdb',
    '--user', 'SYSDBA',
    '--password', 'masterkey'
  ]);

  // 创建传输和 MCP 客户端
  const transport = new ChildProcessTransport(serverProcess);
  const client = new McpClient(transport);

  try {
    // 获取服务器信息
    const serverInfo = await client.getServerInfo();
    console.log('MCP Server:', serverInfo);

    // 列出可用的表
    const tablesResult = await client.executeTool('list-tables', {});
    console.log('Available tables:', tablesResult);

    // 执行 SQL 查询
    const queryResult = await client.executeTool('execute-query', {
      sql: 'SELECT FIRST 10 * FROM EMPLOYEES'
    });
    console.log('Query results:', queryResult);

    // 使用提示生成 SQL
    const sqlGeneration = await client.executePrompt('generate-sql', {
      description: 'Get all premium customers'
    });
    console.log('Generated SQL:', sqlGeneration);
  } catch (error) {
    console.error('Error:', error);
  } finally {
    // 关闭服务器进程
    serverProcess.kill();
  }
}

main().catch(console.error);

Python

# Python 示例
import json
import subprocess
from subprocess import PIPE

class McpFirebirdClient:
    def __init__(self, database_path, user='SYSDBA', password='masterkey'):
        # 启动 MCP 服务器进程
        self.process = subprocess.Popen(
            ['npx', 'mcp-firebird', '--database', database_path, '--user', user, '--password', password],
            stdin=PIPE,
            stdout=PIPE,
            stderr=PIPE,
            text=True,
            bufsize=1
        )

    def send_request(self, method, params={}):
        request = {
            'id': 1,
            'method': method,
            'params': params
        }
        # 将请求发送到服务器
        self.process.stdin.write(json.dumps(request) + '\n')
        self.process.stdin.flush()

        # 读取响应
        response_line = self.process.stdout.readline()
        while not response_line.strip() or response_line.startswith('['):
            response_line = self.process.stdout.readline()

        # 解析并返回 JSON 响应
        return json.loads(response_line)

    def get_server_info(self):
        return self.send_request('getServerInfo')

    def list_tables(self):
        return self.send_request('executeTool', {'name': 'list-tables', 'args': {}})

    def execute_query(self, sql, params=[]):
        return self.send_request('executeTool', {
            'name': 'execute-query',
            'args': {'sql': sql, 'params': params}
        })

    def generate_sql(self, description):
        return self.send_request('executePrompt', {
            'name': 'generate-sql',
            'args': {'description': description}
        })

    def close(self):
        self.process.terminate()

# 客户端用法
client = McpFirebirdClient('/path/to/database.fdb')
try:
    # 获取服务器信息
    server_info = client.get_server_info()
    print(f"MCP Server: {server_info}")

    # 列出表
    tables = client.list_tables()
    print(f"Available tables: {tables}")

    # 执行查询
    results = client.execute_query("SELECT FIRST 10 * FROM EMPLOYEES")
    print(f"Results: {results}")

    # 生成 SQL
    sql = client.generate_sql("List the best-selling products")
    print(f"Generated SQL: {sql}")
finally:
    client.close()

Delphi 和 Lazurus

// Delphi 示例
program McpFirebirdClient;

{$APPTYPE CONSOLE}

uses
  System.SysUtils, System.Classes, System.JSON, System.Net.HttpClient,
  System.Diagnostics, System.IOUtils;

type
  TMcpFirebirdClient = class
  private
    FProcess: TProcess; //For Delphi change to TProcessDelphi and add https://github.com/ferruhkoroglu/TProcessDelphi
    FRequestId: Integer;

    function SendRequest(const Method: string; const Params: TJSONObject = nil): TJSONObject;
    function ReadResponse: string;
  public
    constructor Create(const DatabasePath, User, Password: string);
    destructor Destroy; override;

    function GetServerInfo: TJSONObject;
    function ListTables: TJSONObject;
    function ExecuteQuery(const SQL: string; Params: TArray<Variant> = nil): TJSONObject;
    function GenerateSQL(const Description: string): TJSONObject;
  end;

constructor TMcpFirebirdClient.Create(const DatabasePath, User, Password: string);
begin
  inherited Create;
  FRequestId := 1;

  // Create and configure the process
  FProcess := TProcess.Create(nil);
  FProcess.Executable := 'npx';
  FProcess.Parameters.Add('mcp-firebird');
  FProcess.Parameters.Add('--database');
  FProcess.Parameters.Add(DatabasePath);
  FProcess.Parameters.Add('--user');
  FProcess.Parameters.Add(User);
  FProcess.Parameters.Add('--password');
  FProcess.Parameters.Add(Password);

  FProcess.Options := [poUsePipes, poStderrToOutPut];
  FProcess.Execute;

  // Wait for the server to start
  Sleep(2000);
end;

destructor TMcpFirebirdClient.Destroy;
begin
  FProcess.Free;
  inherited;
end;

function TMcpFirebirdClient.SendRequest(const Method: string; const Params: TJSONObject = nil): TJSONObject;
var
  Request: TJSONObject;
  RequestStr, ResponseStr: string;
begin
  // Create the JSON request
  Request := TJSONObject.Create;
  try
    Request.AddPair('id', TJSONNumber.Create(FRequestId));
    Inc(FRequestId);
    Request.AddPair('method', Method);

    if Assigned(Params) then
      Request.AddPair('params', Params)
    else
      Request.AddPair('params', TJSONObject.Create);

    RequestStr := Request.ToString + #10;

    // Send the request to the process
    FProcess.Input.Write(RequestStr[1], Length(RequestStr) * 2);

    // Read the response
    ResponseStr := ReadResponse;
    Result := TJSONObject.ParseJSONValue(ResponseStr) as TJSONObject;
  finally
    Request.Free;
  end;
end;

function TMcpFirebirdClient.ReadResponse: string;
var
  Buffer: TBytes;
  BytesRead: Integer;
  ResponseStr: string;
begin
  SetLength(Buffer, 4096);
  ResponseStr := '';

  repeat
    BytesRead := FProcess.Output.Read(Buffer[0], Length(Buffer));
    if BytesRead > 0 then
    begin
      SetLength(Buffer, BytesRead);
      ResponseStr := ResponseStr + TEncoding.UTF8.GetString(Buffer);
    end;
  until BytesRead = 0;

  Result := ResponseStr;
end;

function TMcpFirebirdClient.GetServerInfo: TJSONObject;
begin
  Result := SendRequest('getServerInfo');
end;

function TMcpFirebirdClient.ListTables: TJSONObject;
var
  Params: TJSONObject;
begin
  Params := TJSONObject.Create;
  try
    Params.AddPair('name', 'list-tables');
    Params.AddPair('args', TJSONObject.Create);
    Result := SendRequest('executeTool', Params);
  finally
    Params.Free;
  end;
end;

function TMcpFirebirdClient.ExecuteQuery(const SQL: string; Params: TArray<Variant> = nil): TJSONObject;
var
  RequestParams, Args: TJSONObject;
  ParamsArray: TJSONArray;
  I: Integer;
begin
  RequestParams := TJSONObject.Create;
  Args := TJSONObject.Create;
  ParamsArray := TJSONArray.Create;

  try
    // Configure the arguments
    Args.AddPair('sql', SQL);

    if Length(Params) > 0 then
    begin
      for I := 0 to Length(Params) - 1 do
      begin
        case VarType(Params[I]) of
          varInteger: ParamsArray.Add(TJSONNumber.Create(Integer(Params[I])));
          varDouble: ParamsArray.Add(TJSONNumber.Create(Double(Params[I])));
          varBoolean: ParamsArray.Add(TJSONBool.Create(Boolean(Params[I])));
          else ParamsArray.Add(String(Params[I]));
        end;
      end;
    end;

    Args.AddPair('params', ParamsArray);
    RequestParams.AddPair('name', 'execute-query');
    RequestParams.AddPair('args', Args);

    Result := SendRequest('executeTool', RequestParams);
  finally
    RequestParams.Free;
  end;
end;

function TMcpFirebirdClient.GenerateSQL(const Description: string): TJSONObject;
var
  RequestParams, Args: TJSONObject;
begin
  RequestParams := TJSONObject.Create;
  Args := TJSONObject.Create;

  try
    Args.AddPair('description', Description);
    RequestParams.AddPair('name', 'generate-sql');
    RequestParams.AddPair('args', Args);

    Result := SendRequest('executePrompt', RequestParams);
  finally
    RequestParams.Free;
  end;
end;

var
  Client: TMcpFirebirdClient;
  ServerInfo, Tables, QueryResults, GeneratedSQL: TJSONObject;

begin
  try
    WriteLn('Starting MCP Firebird client...');

    // Create the client
    Client := TMcpFirebirdClient.Create('C:\Databases\example.fdb', 'SYSDBA', 'masterkey');
    try
      // Get server information
      ServerInfo := Client.GetServerInfo;
      WriteLn('Server information: ', ServerInfo.ToString);

      // List tables
      Tables := Client.ListTables;
      WriteLn('Available tables: ', Tables.ToString);

      // Execute a query
      QueryResults := Client.ExecuteQuery('SELECT FIRST 10 * FROM EMPLOYEES');
      WriteLn('Query results: ', QueryResults.ToString);

      // Generate SQL
      GeneratedSQL := Client.GenerateSQL('Get all premium customers');
      WriteLn('Generated SQL: ', GeneratedSQL.ToString);
    finally
      Client.Free;
    end;
  except
    on E: Exception do
      WriteLn('Error: ', E.Message);
  end;

  WriteLn('Press ENTER to exit...');
  ReadLn;
end.

Docker 配置

您可以在 Docker 容器中运行 MCP Firebird 服务器，该容器支持 STDIO 和 SSE 传输：

Dockerfile

FROM node:20-alpine

# 不需要外部 Firebird 客户端，因为 MCP Firebird 包含自己的 Node.js 客户端

# 创建应用程序目录
WORKDIR /app

# 复制项目文件
COPY package*.json ./
COPY tsconfig.json ./

# 安装依赖项
RUN npm install

# 复制源代码
COPY src/ ./src/
COPY run-sse-server.js ./
COPY run-sse-proxy.js ./
COPY run-inspector.cjs ./
COPY run-inspector.js ./

# 编译 TypeScript 项目
RUN npm run build

# 公开 SSE 传输的端口
EXPOSE 3003

# 设置默认环境变量
ENV FIREBIRD_HOST=firebird-db
ENV FIREBIRD_PORT=3050
ENV FIREBIRD_USER=SYSDBA
ENV FIREBIRD_PASSWORD=masterkey
ENV FIREBIRD_DATABASE=/firebird/data/database.fdb
ENV TRANSPORT_TYPE=stdio
ENV SSE_PORT=3003
ENV LOG_LEVEL=info

# 启动命令（可以被 docker-compose 覆盖）
CMD ["node", "dist/index.js"]

Docker Compose

version: '3.8'

services:
  # Firebird 数据库服务器
  firebird-db:
    image: jacobalberty/firebird:3.0
    environment:
      ISC_PASSWORD: masterkey
      FIREBIRD_DATABASE: database.fdb
      FIREBIRD_USER: SYSDBA
    volumes:
      - firebird-data:/firebird/data
    ports:
      - "3050:3050"
    networks:
      - mcp-network

  # 带有 STDIO 传输的 MCP Firebird 服务器（用于 Claude Desktop）
  mcp-firebird-stdio:
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      FIREBIRD_HOST: firebird-db
      FIREBIRD_PORT: 3050
      FIREBIRD_USER: SYSDBA
      FIREBIRD_PASSWORD: masterkey
      FIREBIRD_DATABASE: /firebird/data/database.fdb
      TRANSPORT_TYPE: stdio
    depends_on:
      - firebird-db
    networks:
      - mcp-network
    # 用于 Claude Desktop，公开 STDIO
    stdin_open: true
    tty: true

  # 带有 SSE 传输的 MCP Firebird 服务器（用于 Web 客户端）
  mcp-firebird-sse:
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      FIREBIRD_HOST: firebird-db
      FIREBIRD_PORT: 3050
      FIREBIRD_USER: SYSDBA
      FIREBIRD_PASSWORD: masterkey
      FIREBIRD_DATABASE: /firebird/data/database.fdb
      TRANSPORT_TYPE: sse
      SSE_PORT: 3003
    ports:
      - "3003:3003"
    depends_on:
      - firebird-db
    networks:
      - mcp-network
    command: node run-sse-server.js

  # SSE 代理（可选，适用于需要代理支持的客户端）
  mcp-sse-proxy:
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      MCP_SERVER_URL: http://mcp-firebird-sse:3003
      PORT: 3005
    ports:
      - "3005:3005"
    depends_on:
      - mcp-firebird-sse
    networks:
      - mcp-network
    command: node run-sse-proxy.js

networks:
  mcp-network:
    driver: bridge

volumes:
  firebird-data:

使用 Docker 运行

# 使用 Docker Compose 构建和运行
docker compose up -d

# 仅运行 STDIO 版本（用于 Claude Desktop）
docker compose up -d mcp-firebird-stdio

# 仅运行 SSE 版本（用于 Web 客户端）
docker compose up -d mcp-firebird-sse

# 运行带有代理的 SSE 版本（适用于需要代理支持的客户端）
docker compose up -d mcp-firebird-sse mcp-sse-proxy

# 检查日志
docker compose logs -f mcp-firebird-sse

# 停止服务
docker compose down

连接到 Docker 化的 MCP 服务器

使用 Claude Desktop

更新您的 Claude Desktop 配置以使用 Docker 容器：

{
  "mcpServers": {
    "mcp-firebird": {
      "command": "docker",
      "args": [
        "exec",
        "-i",
        "mcp-firebird-stdio",
        "node",
        "dist/index.js"
      ],
      "type": "stdio"
    }
  }
}

使用 Web 客户端

连接到 http://localhost:3003 上的 SSE 端点或通过 http://localhost:3005 上的代理连接。

使用 MCP Inspector

# 直接连接到 SSE 服务器
npx @modelcontextprotocol/inspector http://localhost:3003

# 或通过代理连接
npx @modelcontextprotocol/inspector http://localhost:3005

最近更新

2.0.5 版本

MCP Firebird 已得到显著增强，包括：

• SSE 传输支持: 添加了强大的服务器发送事件 (SSE) 传输实现
• 代理支持: 添加了通过 SSE 代理连接的支持
• 多传输架构: 支持 STDIO 和 SSE 传输
• 增强的安全性: 改进的安全选项和配置
• Docker 支持: 更新了所有传输类型的 Docker 配置

1.0.93 版本（之前的稳定版本）

MCP Firebird 得到了显著改进，包括：

1. 增强的 TypeScript 接口:

   • 用于更好类型安全的新接口（FirebirdDatabase、ConfigOptions、DatabaseInfo、TableInfo 等）
   • 对所有参数和返回值的更严格的类型检查

2. 改进的错误处理:

   • 用于更好错误分类的自定义 FirebirdError 类
   • 详细检测不同错误类型（连接、语法、权限等）
   • 更具信息性的错误消息，便于调试

3. 新功能和工具:

   • 用于 API 发现的 get-methods 工具
   • 用于分析表和优化查询的新提示
   • 用于详细表结构的 describeTable 函数
   • 用于简单表名列表的 listTables 函数

4. 更好的文档:

   • 所有函数的全面 JSDoc
   • 改进的 MCP 工具描述，包含 Firebird 特定信息
   • 明确说明 Firebird 使用 FIRST/ROWS 而不是 LIMIT 进行分页

5. 安全改进:

   • 显式 SQL 参数验证
   • 增强的 SQL 注入防护
   • 可配置的表和操作访问限制

6. 代码质量:

   • 删除不必要的文件（server.js、server.new.js、test-*.js 等）
   • 更紧凑的 JSON 响应（删除不必要的空格）
   • 一致的日志记录方法

用例

1. 使用 AI 进行数据分析:

   • 分析历史销售趋势
   • 识别财务数据中的模式
   • 检测交易记录中的异常

2. SQL 查询生成:

   • 从自然语言描述创建复杂查询
   • 优化现有查询以提高性能
   • 在不同 SQL 方言之间转换查询

3. 自动化文档:

   • 生成有关数据库结构的文档
   • 解释表和模式之间的关系
   • 创建详细的数据字典

4. 开发协助:

   • 建议索引以提高性能
   • 提出模式规范化
   • 帮助在系统之间进行数据迁移

销售分析用法示例

与 Claude 的交互：

用户：连接到我的 Firebird 数据库并分析上个季度按地区的销售趋势。

Claude：我将连接到您的 Firebird 数据库以分析区域销售趋势。

[Claude 使用 MCP Firebird 执行多个 SQL 查询]

根据上个季度的数据，我确定了以下趋势：

1. 北部地区的增长率比上个季度增长了 12.5%
2. 南部地区的电子产品销量下降了 3.2%
3. “Laptop Pro X” 产品是所有地区最畅销的产品
4. 东部地区的销售额显示出周期性模式，周末达到峰值

从图形上看，按地区划分的销售额分布为：
[Claude 根据数据生成的图表]

您想深入研究任何特定地区或产品类别吗？

查询优化和性能分析示例

用户：我有一个运行缓慢的查询，你能优化它吗？
SELECT c.CUSTOMER_NAME, SUM(o.ORDER_TOTAL)
FROM CUSTOMERS c
JOIN ORDERS o ON c.CUSTOMER_ID = o.CUSTOMER_ID
WHERE o.ORDER_DATE > '2024-01-01'
GROUP BY c.CUSTOMER_NAME
ORDER BY SUM(o.ORDER_TOTAL) DESC

Claude：我将分析此查询以优化它。首先，让我检查执行计划和性能。

[Claude 使用 MCP Firebird 的 get-execution-plan 工具]

执行计划显示：
- 对 ORDERS 表进行全表扫描
- 与 CUSTOMERS 的嵌套循环连接
- 用于 ORDER BY 子句的排序操作
- 没有索引用于日期过滤

[Claude 使用 MCP Firebird 的 analyze-query-performance 工具]

性能分析：
- 平均执行时间：1250 毫秒
- 最短执行时间：1150 毫秒
- 最长执行时间：1380 毫秒
- 返回的行数：487

[Claude 使用 MCP Firebird 的 analyze-missing-indexes 工具]

缺失索引分析建议：
- CREATE INDEX IDX_ORDERS_ORDER_DATE ON ORDERS (ORDER_DATE);
- CREATE INDEX IDX_ORDERS_CUSTOMER_ID ON ORDERS (CUSTOMER_ID);

基于这些分析，我确定了几个优化机会：

1. 当前查询没有有效地使用索引
2. SUM(o.ORDER_TOTAL) 的计算执行了两次
3. 我们应该在 JOIN 和 WHERE 列上添加索引

这是优化后的版本：

```sql
SELECT c.CUSTOMER_NAME, total_sales
FROM CUSTOMERS c
JOIN (
  SELECT CUSTOMER_ID, SUM(ORDER_TOTAL) as total_sales
  FROM ORDERS
  WHERE ORDER_DATE > '2024-01-01'
  GROUP BY CUSTOMER_ID
) o ON c.CUSTOMER_ID = o.CUSTOMER_ID
ORDER BY total_sales DESC

此版本：

• 在连接之前减少数据集
• 仅计算一次总和
• 将受益于推荐的索引

[Claude 在新查询上使用 MCP Firebird 的 analyze-query-performance 工具]

优化后：

• 平均执行时间：320 毫秒（快 74%）
• 返回的行数：487（相同的结果）

我建议创建这些索引以进一步提高性能：

CREATE INDEX IDX_ORDERS_ORDER_DATE ON ORDERS (ORDER_DATE);
CREATE INDEX IDX_ORDERS_CUSTOMER_ID ON ORDERS (CUSTOMER_ID);

## 与 AI 代理集成

### 终端中的 Claude

您可以在终端中使用带有 Claude 的 MCP Firebird 服务器：

```bash
# 在一个终端中启动 MCP 服务器
npx mcp-firebird --database /path/to/database.fdb --user SYSDBA --password masterkey

# 在另一个终端中，将 anthropic CLI 与 MCP 一起使用
anthropic messages create \
  --model claude-3-opus-20240229 \
  --max-tokens 4096 \
  --mcp "npx mcp-firebird --database /path/to/database.fdb --user SYSDBA --password masterkey" \
  --message "Analyze the structure of my Firebird database"

其他 AI 代理

MCP Firebird 服务器与任何实现 MCP 协议的代理兼容，只需提供启动服务器的命令：

npx mcp-firebird --database /path/to/database.fdb --user SYSDBA --password masterkey

安全

MCP Firebird 服务器实施了全面的安全措施：

• 使用 Zod 模式进行输入验证
• SQL 查询清理以防止注入攻击
• 用于数据库连接的安全凭据处理
• 通过参数化查询防止 SQL 注入
• 限制破坏性操作，如 DROP 和 TRUNCATE
• 用于查询结果中敏感信息的数据脱敏
• 用于安全和合规性的所有数据库操作的审计日志
• 用于根据安全规则过滤查询结果的行级安全性
• 资源限制以防止滥用和 DoS 攻击
• 速率限制以控制每个会话的查询数量

安全配置

您可以使用 JSON 配置文件配置安全选项。在项目根目录中创建一个名为 security.json 的文件：

{
  "security": {
    "allowedTables": ["EMPLOYEES", "DEPARTMENTS"],
    "forbiddenTables": ["USERS", "PASSWORDS"],
    "allowedOperations": ["SELECT", "EXECUTE"],
    "forbiddenOperations": ["DROP", "TRUNCATE", "ALTER"],
    "maxRows": 1000,
    "queryTimeout": 5000,
    "dataMasking": [
      {
        "columns": ["CREDIT_CARD", "SSN"],
        "pattern": "\\d{4}-\\d{4}-\\d{