Pájaro de fuego MCP

Implementación del protocolo MCP de Anthropic para bases de datos Firebird.

¿Qué es MCP Firebird y para qué sirve?

MCP Firebird es un servidor que implementa el Protocolo de Contexto de Modelo (MCP) de Anthropic para bases de datos SQL de Firebird . Permite a los Modelos de Lenguaje Grandes (LLM) como Claude acceder, analizar y manipular datos en bases de datos de Firebird de forma segura y controlada.

A continuación encontrará casos de uso y ejemplos.

Instalación

Instalación mediante herrería

Para instalar MCP Firebird para Claude Desktop automáticamente a través de Smithery :

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

Instalación manual

# Global installation
npm install -g mcp-firebird

# Project installation
npm install mcp-firebird

Configuración

Variables de entorno

Puede configurar el servidor utilizando variables de entorno:

# Basic configuration
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

# Directory configuration (alternative)
export FIREBIRD_DATABASE_DIR=/path/to/databases  # Directory with databases

# Logging configuration
export LOG_LEVEL=info  # Options: debug, info, warn, error

Puede crear un archivo .env en la raíz del proyecto para configurar estas variables. Se proporciona un archivo .env.example como plantilla.

Ejemplo de archivo .env

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

Uso con npx

Puedes ejecutar el servidor directamente con npx:

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

Uso del transporte SSE (eventos enviados por el servidor)

El servidor Firebird de MCP también admite el transporte SSE, que permite a los clientes conectarse a través de HTTP:

# Set the transport type to SSE in your .env file
TRANSPORT_TYPE=sse
SSE_PORT=3003

# Run the server with SSE transport
npm run sse

Luego puede conectarse al servidor mediante el Inspector MCP:

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

O utilice el script proporcionado:

npm run inspector-sse

Ejemplos de clientes de SSE

Proporcionamos varios clientes de ejemplo que demuestran cómo conectarse al servidor MCP Firebird mediante SSE:

HTML/JavaScript : consulte examples/sse-client.html para un cliente basado en navegador
Node.js : consulte examples/sse-client.js para un cliente Node.js
Python : consulte examples/sse_client.py para un cliente Python

Para obtener documentación detallada sobre el uso del transporte SSE, consulte docs/sse-examples.md .

Configuración con Claude Desktop

Para utilizar el servidor Firebird MCP con Claude Desktop:

Agregue la siguiente configuración:

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

Recursos y funciones

El servidor MCP Firebird ofrece:

Bases de datos : Lista de todas las bases de datos disponibles
Tablas : Lista de todas las tablas de la base de datos
Vistas : Lista de todas las vistas en la base de datos
Procedimientos almacenados : acceso a procedimientos en la base de datos
Esquemas de tabla : Estructura detallada de cada tabla
Datos : Acceso a los datos de la tabla
Análisis de rendimiento : analice el tiempo de ejecución de las consultas y las métricas de rendimiento
Análisis del plan de ejecución : obtener y analizar planes de ejecución de SQL
Recomendaciones de índices : identificar los índices faltantes que podrían mejorar el rendimiento
Copia de seguridad y restauración de bases de datos : crear y restaurar copias de seguridad de bases de datos
Validación de la base de datos : comprobar la integridad de la base de datos y corregir errores
Opciones de seguridad mejoradas : enmascaramiento de datos, registro de auditoría y límites de recursos

Herramientas disponibles

list-tables : enumera todas las tablas de la base de datos
{} // No parameters required
describe-table : Describe la estructura de una tabla
{ "tableName": "EMPLOYEES" }
execute-query : ejecuta una consulta SQL en la base de datos
{ "sql": "SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID = 10", "params": [] // Optional parameters for prepared queries }
get-field-descriptions : Obtiene descripciones de campos
{ "tableName": "EMPLOYEES" }
analizar-rendimiento-de-consultas : analiza el rendimiento de una consulta SQL
{ "sql": "SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID = 10", "params": [], // Optional parameters for prepared queries "iterations": 3 // Optional number of iterations for averaging (default: 3) }
get-execution-plan : obtiene el plan de ejecución para una consulta SQL
{ "sql": "SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID = 10", "params": [] // Optional parameters for prepared queries }
analizar-índices-faltantes : analiza una consulta SQL para identificar índices faltantes
{ "sql": "SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID = 10" }
backup-database : Crea una copia de seguridad de la base de datos de Firebird
{ "backupPath": "C:\\backups\\mydb_backup.fbk", "options": { "format": "gbak", // "gbak" (full backup) or "nbackup" (incremental) "compress": true, // Whether to compress the backup "metadata_only": false, // Whether to backup only metadata (no data) "verbose": true // Whether to show detailed progress } }
restore-database : Restaura una base de datos Firebird desde una copia de seguridad
{ "backupPath": "C:\\backups\\mydb_backup.fbk", "targetPath": "C:\\databases\\restored_db.fdb", "options": { "replace": true, // Whether to replace the target database if it exists "pageSize": 4096, // Page size for the restored database "verbose": true // Whether to show detailed progress } }
validate-database : valida la integridad de la base de datos de Firebird

{
  "options": {
    "checkData": true,  // Whether to validate data integrity
    "checkIndexes": true,  // Whether to validate indexes
    "fixErrors": false,  // Whether to attempt to fix errors
    "verbose": true  // Whether to show detailed progress
  }
}

La herramienta get-field-descriptions es especialmente útil para los modelos de IA, ya que recupera comentarios de los metadatos RDB$DESCRIPTION de Firebird, proporcionando contexto semántico adicional sobre el propósito de cada campo.

Las herramientas de análisis de rendimiento ( analyze-query-performance , get-execution-plan y analyze-missing-indexes ) ayudan a optimizar las consultas de bases de datos al proporcionar información sobre el tiempo de ejecución, los planes de ejecución y las recomendaciones de índices.

Las herramientas de administración de bases de datos ( backup-database , restore-database y validate-database ) proporcionan funcionalidad para el mantenimiento de la base de datos y la recuperación ante desastres.

Indicaciones disponibles

query-data : Consulta datos usando lenguaje natural
Find all employees in the sales department hired in 2023
analizar-tabla : Analizar la estructura de una tabla
Analyze the EMPLOYEES table and explain its structure
optimizar-consulta : Optimizar una consulta SQL
Optimize: SELECT * FROM EMPLOYEES WHERE LAST_NAME = 'Smith'
generate-sql : Generar SQL a partir de una descripción
Generate a query to get the 10 best-selling products

Uso en diferentes idiomas

TypeScript/JavaScript

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

async function main() {
  // Start the MCP server process
  const serverProcess = spawn('npx', [
    'mcp-firebird',
    '--database', '/path/to/database.fdb',
    '--user', 'SYSDBA',
    '--password', 'masterkey'
  ]);

  // Create a transport and an MCP client
  const transport = new ChildProcessTransport(serverProcess);
  const client = new McpClient(transport);

  try {
    // Get server information
    const serverInfo = await client.getServerInfo();
    console.log('MCP Server:', serverInfo);

    // List available tables
    const tablesResult = await client.executeTool('list-tables', {});
    console.log('Available tables:', tablesResult);

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

    // Use a prompt to generate 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 {
    // Close the server process
    serverProcess.kill();
  }
}

main().catch(console.error);

Pitón

# Example with Python
import json
import subprocess
from subprocess import PIPE

class McpFirebirdClient:
    def __init__(self, database_path, user='SYSDBA', password='masterkey'):
        # Start the MCP server process
        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
        }
        # Send the request to the server
        self.process.stdin.write(json.dumps(request) + '\n')
        self.process.stdin.flush()

        # Read the response
        response_line = self.process.stdout.readline()
        while not response_line.strip() or response_line.startswith('['):
            response_line = self.process.stdout.readline()

        # Parse and return the JSON response
        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 usage
client = McpFirebirdClient('/path/to/database.fdb')
try:
    # Get server information
    server_info = client.get_server_info()
    print(f"MCP Server: {server_info}")

    # List tables
    tables = client.list_tables()
    print(f"Available tables: {tables}")

    # Execute a query
    results = client.execute_query("SELECT FIRST 10 * FROM EMPLOYEES")
    print(f"Results: {results}")

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

Delfos y Lázaro

// Example with 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.

Configuración de Docker

Puede ejecutar el servidor MCP Firebird en un contenedor Docker con soporte para transportes STDIO y SSE:

Archivo Docker

FROM node:20-alpine

# No external Firebird client needed as MCP Firebird includes its own Node.js client

# Create application directory
WORKDIR /app

# Copy project files
COPY package*.json ./
COPY tsconfig.json ./

# Install dependencies
RUN npm install

# Copy source code
COPY src/ ./src/
COPY run-sse-server.js ./
COPY run-sse-proxy.js ./
COPY run-inspector.cjs ./
COPY run-inspector.js ./

# Compile the TypeScript project
RUN npm run build

# Expose port for SSE transport
EXPOSE 3003

# Set default environment variables
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

# Start command (can be overridden by docker-compose)
CMD ["node", "dist/index.js"]

Docker Compose

version: '3.8'

services:
  # Firebird database server
  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

  # MCP Firebird server with STDIO transport (for 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
    # For use with Claude Desktop, expose STDIO
    stdin_open: true
    tty: true

  # MCP Firebird server with SSE transport (for web clients)
  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 Proxy (optional, for clients that need proxy support)
  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:

Ejecutando con Docker

# Build and run with Docker Compose
docker compose up -d

# Run only the STDIO version (for Claude Desktop)
docker compose up -d mcp-firebird-stdio

# Run only the SSE version (for web clients)
docker compose up -d mcp-firebird-sse

# Run the SSE version with proxy (for clients that need proxy support)
docker compose up -d mcp-firebird-sse mcp-sse-proxy

# Check logs
docker compose logs -f mcp-firebird-sse

# Stop services
docker compose down

Conexión al servidor MCP Dockerizado

Con Claude Desktop

Actualice su configuración de Claude Desktop para usar el contenedor Docker:

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

Con clientes web

Conéctese al punto final SSE en http://localhost:3003 o a través del proxy en http://localhost:3005 .

Con MCP Inspector

# Connect directly to the SSE server
npx @modelcontextprotocol/inspector http://localhost:3003

# Or connect through the proxy
npx @modelcontextprotocol/inspector http://localhost:3005

Actualizaciones recientes

Versión 2.0.5

MCP Firebird se ha mejorado significativamente con:

Compatibilidad con transporte SSE : se agregó una implementación robusta de transporte de eventos enviados por el servidor (SSE)
Compatibilidad con proxy : se agregó compatibilidad para conectarse a través de un proxy SSE
Arquitectura de transporte múltiple : compatibilidad con transportes STDIO y SSE
Seguridad mejorada : opciones de seguridad y configuración mejoradas
Compatibilidad con Docker : configuración de Docker actualizada para todos los tipos de transporte

Versión 1.0.93 (Versión estable anterior)

MCP Firebird se ha mejorado significativamente con:

Interfaces TypeScript mejoradas :
- Nuevas interfaces para una mejor seguridad de tipos (FirebirdDatabase, ConfigOptions, DatabaseInfo, TableInfo, etc.)
- Tipificación más estricta para todos los parámetros y valores de retorno
Manejo de errores mejorado :
- Clase FirebirdError personalizada para una mejor categorización de errores
- Detección detallada de diferentes tipos de errores (conexión, sintaxis, permisos, etc.)
- Mensajes de error más informativos para una depuración más sencilla
Nuevas funciones y herramientas :
- herramienta get-methods para el descubrimiento de API
- Nuevas indicaciones para analizar tablas y optimizar consultas
- Función describeTable para la estructura detallada de la tabla
- Función listTables para listar nombres de tablas simples
Mejor documentación :
- JSDoc completo para todas las funciones
- Descripciones de herramientas MCP mejoradas con información específica de Firebird
- Especificación clara de que Firebird utiliza FIRST/ROWS en lugar de LIMIT para la paginación
Mejoras de seguridad :
- Validación explícita de parámetros SQL
- Prevención mejorada de inyección SQL
- Restricciones de acceso configurables para tablas y operaciones
Calidad del código :
- Eliminación de archivos innecesarios (server.js, server.new.js, test-*.js, etc.)
- Respuestas JSON más compactas (se eliminaron los espacios innecesarios)
- Enfoque de registro consistente

Casos de uso

Análisis de datos con IA :
- Analizar las tendencias históricas de ventas
- Identificar patrones en datos financieros
- Detectar anomalías en los registros de transacciones
Generación de consultas SQL :
- Crear consultas complejas a partir de descripciones en lenguaje natural
- Optimizar las consultas existentes para mejorar el rendimiento
- Traducir consultas entre diferentes dialectos SQL
Documentación automatizada :
- Generar documentación sobre la estructura de la base de datos
- Explicar las relaciones entre tablas y esquemas.
- Crear diccionarios de datos detallados
Asistencia para el desarrollo :
- Sugerir índices para mejorar el rendimiento
- Proponer normalizaciones de esquemas
- Ayuda con la migración de datos entre sistemas

Ejemplo de uso del análisis de ventas

Interacción con 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?

Ejemplo de optimización de consultas y análisis de rendimiento

User: I have this query that's running slowly, can you optimize it?
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: I'll analyze this query to optimize it. First, let me check the execution plan and performance.

[Claude uses MCP Firebird's get-execution-plan tool]

The execution plan shows:
- Full table scan on ORDERS table
- Nested loop join with CUSTOMERS
- Sorting operation for ORDER BY clause
- No indexes being used for the date filtering

[Claude uses MCP Firebird's analyze-query-performance tool]

Performance analysis:
- Average execution time: 1250ms
- Minimum execution time: 1150ms
- Maximum execution time: 1380ms
- Rows returned: 487

[Claude uses MCP Firebird's analyze-missing-indexes tool]

Missing index analysis recommends:
- CREATE INDEX IDX_ORDERS_ORDER_DATE ON ORDERS (ORDER_DATE);
- CREATE INDEX IDX_ORDERS_CUSTOMER_ID ON ORDERS (CUSTOMER_ID);

Based on these analyses, I've identified several optimization opportunities:

1. The current query doesn't efficiently use indexes
2. The calculation of SUM(o.ORDER_TOTAL) is performed twice
3. We should add indexes on the JOIN and WHERE columns

Here's the optimized version:

```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

Esta versión:

Reduce el conjunto de datos antes de unirlos
Calcula la suma solo una vez
Se beneficiará de los índices recomendados

[Claude utiliza la herramienta de análisis de rendimiento de consultas de MCP Firebird en la nueva consulta]

Después de la optimización:

Tiempo promedio de ejecución: 320 ms (74 % más rápido)
Filas devueltas: 487 (mismos resultados)

Recomiendo crear estos índices para mejorar aún más el rendimiento:

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

## Integration with AI Agents

### Claude in the Terminal

You can use the MCP Firebird server with Claude in the terminal:

```bash
# Start the MCP server in one terminal
npx mcp-firebird --database /path/to/database.fdb --user SYSDBA --password masterkey

# In another terminal, use anthropic CLI with 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"

Otros agentes de IA

El servidor MCP Firebird es compatible con cualquier agente que implemente el protocolo MCP, simplemente proporcionando el comando para iniciar el servidor:

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

Seguridad

El servidor Firebird de MCP implementa medidas de seguridad integrales:

Validación de entrada con esquemas Zod
Sanitización de consultas SQL para prevenir ataques de inyección
Manejo seguro de credenciales para conexiones de bases de datos
Prevención de inyección SQL mediante consultas parametrizadas
Restricción de operaciones destructivas como DROP y TRUNCATE
Enmascaramiento de datos para información confidencial en los resultados de consultas
Registro de auditoría de todas las operaciones de la base de datos para seguridad y cumplimiento
Seguridad a nivel de fila para filtrar los resultados de la consulta según reglas de seguridad
Límites de recursos para prevenir abusos y ataques DoS
Limitación de velocidad para controlar el número de consultas por sesión

Configuración de seguridad

Puede configurar las opciones de seguridad mediante un archivo de configuración JSON. Cree un archivo llamado security.json en la raíz del proyecto:

{
  "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{4}-\\d{4}",
        "replacement": "XXXX-XXXX-XXXX-$&"
      }
    ],
    "rowFilters": {
      "EMPLOYEES": "DEPARTMENT_ID = 10"
    },
    "audit": {
      "enabled": true,
      "destination": "file",
      "auditFile": "./logs/audit.log",
      "detailLevel": "medium",
      "logQueries": true
    },
    "resourceLimits": {
      "maxRowsPerQuery": 5000,
      "maxResponseSize": 5242880,
      "maxQueryCpuTime": 10000,
      "maxQueriesPerSession": 100,
      "rateLimit": {
        "queriesPerMinute": 60,
        "burstLimit": 20
      }
    },
    "authorization": {
      "type": "basic",
      "rolePermissions": {
        "admin": {
          "allTablesAllowed": true,
          "operations": ["SELECT", "INSERT", "UPDATE", "DELETE"]
        },
        "user": {
          "tables": ["EMPLOYEES", "DEPARTMENTS"],
          "operations": ["SELECT"]
        }
      }
    }
  }
}

A continuación, especifique la ruta al archivo de configuración al iniciar el servidor:

export SECURITY_CONFIG_PATH=./security.json

Depuración y solución de problemas

Para habilitar el modo de depuración:

export LOG_LEVEL=debug

Problemas comunes

Error de conexión a la base de datos :
- Verificar credenciales y ruta de la base de datos
- Asegúrese de que el servidor Firebird esté ejecutándose
- Compruebe que el usuario tenga permisos suficientes
El servidor no aparece en Claude Desktop :
- Reiniciar Claude Desktop
- Verifique la configuración en claude_desktop_config.json
- Asegúrese de que la ruta de la base de datos sea absoluta
Problemas con STDIO :
- Asegúrese de que la salida estándar no esté siendo redirigida
- No utilice console.log para depurar (utilice console.error en su lugar)

Licencia

Instituto Tecnológico de Massachusetts (MIT)

Integrations