MCP Firebird
by PuroDelphi
Verified
# MCP Firebird
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)](https://github.com/anthropics/anthropic-cookbook/tree/main/model_context_protocol) de Anthropic para bases de datos Firebird SQL. Permite a los Modelos de Lenguaje de Gran Tamaño (LLMs) como Claude acceder, analizar y manipular datos en bases de datos Firebird de manera segura y controlada.
Más abajo encontrarás casos y ejemplos de uso.
## Instalación
```bash
# Instalación global
npm install -g mcp-firebird
# Instalación en un proyecto
npm install mcp-firebird
```
## Configuración
### Variables de entorno
Puedes configurar el servidor usando variables de entorno:
```bash
# Configuración básica
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 # Opcional
# Configuración de directorio (alternativa)
export FIREBIRD_DATABASE_DIR=/path/to/databases # Directorio con bases de datos
```
### Uso con npx
Puedes ejecutar el servidor directamente con npx:
```bash
npx mcp-firebird --host localhost --port 3050 --database /path/to/database.fdb --user SYSDBA --password masterkey
```
## Configuración con Claude Desktop
Para usar el servidor MCP de Firebird con 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>
Añade la siguiente configuración:
```json
{
"mcpServers": {
"mcp-firebird": {
"command": "npx",
"args": [
"mcp-firebird",
"--host",
"localhost",
"--port",
"3050",
"--database",
"C:\\Databases\\example.fdb",
"--user",
"SYSDBA",
"--password",
"masterkey"
]
}
}
}
```
<Warning>
Asegúrate de usar rutas absolutas en la configuración.
</Warning>
<Note>
Después de guardar el archivo, necesitas reiniciar Claude Desktop completamente.
</Note>
## Recursos y Funcionalidades
El servidor MCP Firebird ofrece:
- **Bases de datos**: Listado de todas las bases de datos disponibles
- **Tablas**: Lista de todas las tablas en la base de datos
- **Vistas**: Lista de todas las vistas en la base de datos
- **Procedimientos almacenados**: Acceso a los procedimientos en la base de datos
- **Esquemas de tablas**: Estructura detallada de cada tabla
- **Datos**: Acceso a los datos de las tablas
## Herramientas disponibles
1. **list-tables**: Lista todas las tablas en la base de datos
```json
{} // No requiere parámetros
```
2. **describe-table**: Describe la estructura de una tabla
```json
{
"tableName": "EMPLOYEES"
}
```
3. **execute-query**: Ejecuta una consulta SQL en la base de datos
```json
{
"sql": "SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID = 10",
"params": [] // Parámetros opcionales para consultas preparadas
}
```
4. **get-field-descriptions**: Obtiene las descripciones de los campos
```json
{
"tableName": "EMPLOYEES"
}
```
La herramienta **get-field-descriptions** es especialmente útil para los modelos de IA, ya que obtiene los comentarios de metadatos RDB$DESCRIPTION de Firebird, proporcionando contexto semántico adicional sobre el propósito de cada campo.
## Prompts disponibles
1. **query-data**: Consulta datos usando lenguaje natural
```
Encuentra todos los empleados del departamento de ventas contratados en 2023
```
2. **analyze-table**: Analiza la estructura de una tabla
```
Analiza la tabla EMPLOYEES y explica su estructura
```
3. **optimize-query**: Optimiza una consulta SQL
```
Optimiza: SELECT * FROM EMPLOYEES WHERE LAST_NAME = 'Smith'
```
4. **generate-sql**: Genera SQL a partir de una descripción
```
Genera una consulta para obtener los 10 productos más vendidos
```
## Uso desde diferentes lenguajes
### TypeScript/JavaScript
```typescript
// Ejemplo con TypeScript
import { McpClient, ChildProcessTransport } from '@modelcontextprotocol/sdk';
import { spawn } from 'child_process';
async function main() {
// Iniciar el proceso del servidor MCP
const serverProcess = spawn('npx', [
'mcp-firebird',
'--database', '/path/to/database.fdb',
'--user', 'SYSDBA',
'--password', 'masterkey'
]);
// Crear un transporte y un cliente MCP
const transport = new ChildProcessTransport(serverProcess);
const client = new McpClient(transport);
try {
// Obtener información del servidor
const serverInfo = await client.getServerInfo();
console.log('Servidor MCP:', serverInfo);
// Listar tablas disponibles
const tablesResult = await client.executeTool('list-tables', {});
console.log('Tablas disponibles:', tablesResult);
// Ejecutar una consulta SQL
const queryResult = await client.executeTool('execute-query', {
sql: 'SELECT FIRST 10 * FROM EMPLOYEES'
});
console.log('Resultados de la consulta:', queryResult);
// Utilizar un prompt para generar SQL
const sqlGeneration = await client.executePrompt('generate-sql', {
description: 'Obtener todos los clientes premium'
});
console.log('SQL generado:', sqlGeneration);
} catch (error) {
console.error('Error:', error);
} finally {
// Cerrar el proceso del servidor
serverProcess.kill();
}
}
main().catch(console.error);
```
### Python
```python
# Ejemplo con Python
import json
import subprocess
from subprocess import PIPE
class McpFirebirdClient:
def __init__(self, database_path, user='SYSDBA', password='masterkey'):
# Iniciar el proceso del servidor 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
}
# Enviar la solicitud al servidor
self.process.stdin.write(json.dumps(request) + '\n')
self.process.stdin.flush()
# Leer la respuesta
response_line = self.process.stdout.readline()
while not response_line.strip() or response_line.startswith('['):
response_line = self.process.stdout.readline()
# Parsear y devolver la respuesta 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()
# Uso del cliente
client = McpFirebirdClient('/path/to/database.fdb')
try:
# Obtener información del servidor
server_info = client.get_server_info()
print(f"Servidor MCP: {server_info}")
# Listar tablas
tables = client.list_tables()
print(f"Tablas disponibles: {tables}")
# Ejecutar una consulta
results = client.execute_query("SELECT FIRST 10 * FROM EMPLOYEES")
print(f"Resultados: {results}")
# Generar SQL
sql = client.generate_sql("Listar los productos más vendidos")
print(f"SQL generado: {sql}")
finally:
client.close()
```
### Delphi
```delphi
// Ejemplo con 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; //Para Delphi cambiar por TProcessDelphi y agregue 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;
// Crear y configurar el proceso
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;
// Esperar a que el servidor se inicie
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
// Crear la solicitud JSON
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;
// Enviar la solicitud al proceso
FProcess.Input.Write(RequestStr[1], Length(RequestStr) * 2);
// Leer la respuesta
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
// Configurar los argumentos
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('Iniciando cliente MCP Firebird...');
// Crear el cliente
Client := TMcpFirebirdClient.Create('C:\Databases\example.fdb', 'SYSDBA', 'masterkey');
try
// Obtener información del servidor
ServerInfo := Client.GetServerInfo;
WriteLn('Información del servidor: ', ServerInfo.ToString);
// Listar tablas
Tables := Client.ListTables;
WriteLn('Tablas disponibles: ', Tables.ToString);
// Ejecutar una consulta
QueryResults := Client.ExecuteQuery('SELECT FIRST 10 * FROM EMPLOYEES');
WriteLn('Resultados de la consulta: ', QueryResults.ToString);
// Generar SQL
GeneratedSQL := Client.GenerateSQL('Obtener todos los clientes premium');
WriteLn('SQL generado: ', GeneratedSQL.ToString);
finally
Client.Free;
end;
except
on E: Exception do
WriteLn('Error: ', E.Message);
end;
WriteLn('Presiona ENTER para salir...');
ReadLn;
end.
```
## Configuración con Docker
Puedes ejecutar el servidor MCP Firebird en un contenedor Docker:
### Dockerfile
```dockerfile
FROM node:18-alpine
# Instalar dependencias necesarias para Firebird
RUN apk add --no-cache firebird-client
# Crear directorio de la aplicación
WORKDIR /app
# Copiar archivos del proyecto
COPY package*.json ./
RUN npm install
# Copiar el código fuente
COPY . .
# Compilar el proyecto TypeScript
RUN npm run build
# Exponer puerto si se usa HTTP (opcional)
# EXPOSE 3000
# Establecer variables de entorno por defecto
ENV FIREBIRD_HOST=firebird-db
ENV FIREBIRD_PORT=3050
ENV FIREBIRD_USER=SYSDBA
ENV FIREBIRD_PASSWORD=masterkey
ENV FIREBIRD_DATABASE=/firebird/data/database.fdb
# Comando de inicio
CMD ["node", "dist/index.js"]
```
### Docker Compose
```yaml
version: '3.8'
services:
# Servidor de base de datos 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
# Servidor MCP Firebird
mcp-firebird:
build:
context: .
dockerfile: Dockerfile
environment:
FIREBIRD_HOST: firebird-db
FIREBIRD_PORT: 3050
FIREBIRD_USER: SYSDBA
FIREBIRD_PASSWORD: masterkey
FIREBIRD_DATABASE: /firebird/data/database.fdb
depends_on:
- firebird-db
networks:
- mcp-network
# Para usar con Claude Desktop, exponer STDIO
stdin_open: true
tty: true
networks:
mcp-network:
driver: bridge
volumes:
firebird-data:
```
### Ejecución con Docker
```bash
# Construir y ejecutar con Docker Compose
docker compose up -d
# Verificar logs
docker compose logs -f mcp-firebird
# Detener los servicios
docker compose down
```
### Casos de uso
1. **Análisis de datos con IA**:
- Analizar tendencias de ventas históricas
- Identificar patrones en datos financieros
- Detectar anomalías en registros de transacciones
2. **Generación de consultas SQL**:
- Crear consultas complejas a partir de descripciones en lenguaje natural
- Optimizar consultas existentes para mejorar el rendimiento
- Traducir consultas entre diferentes dialectos SQL
3. **Documentación automatizada**:
- Generar documentación sobre la estructura de la base de datos
- Explicar relaciones entre tablas y esquemas
- Crear diccionarios de datos detallados
4. **Asistencia en desarrollo**:
- Sugerir índices para mejorar el rendimiento
- Proponer normalizaciones de esquemas
- Ayudar con la migración de datos entre sistemas
### Ejemplo de uso para análisis de ventas
Interacción con Claude:
```
Usuario: Conéctate a mi base de datos Firebird y analiza las tendencias de ventas por región en el último trimestre.
Claude: Me conectaré a tu base de datos Firebird para analizar las tendencias de ventas regionales.
[Claude usa MCP Firebird para ejecutar varias consultas SQL]
Basado en los datos del último trimestre, he identificado las siguientes tendencias:
1. La región Norte ha experimentado un crecimiento del 12.5% respecto al trimestre anterior
2. La región Sur muestra una disminución del 3.2% en productos electrónicos
3. El producto "Laptop Pro X" es el más vendido en todas las regiones
4. Las ventas en la región Este muestran un patrón cíclico con picos los fines de semana
Gráficamente, la distribución de ventas por región es:
[Gráfico generado por Claude basado en los datos]
¿Te gustaría profundizar en alguna región o categoría de productos específica?
```
### Ejemplo de optimización de consultas
```
Usuario: Tengo esta consulta que está funcionando lenta, ¿puedes optimizarla?
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: Analizaré esta consulta para optimizarla.
[Claude usa MCP Firebird para analizar el esquema y la consulta]
He identificado varias oportunidades de optimización:
1. La consulta actual no utiliza índices eficientemente
2. El cálculo de SUM(o.ORDER_TOTAL) se realiza dos veces
Aquí está la versión optimizada:
```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 la unión
- Calcula la suma una sola vez
- Podría beneficiarse de un índice en ORDERS(ORDER_DATE, CUSTOMER_ID, ORDER_TOTAL)
Al ejecutar ambas consultas en tu base de datos, la versión optimizada es aproximadamente 45% más rápida.
```
## Configuración de seguridad
La seguridad es una prioridad en MCP Firebird. A continuación, se detallan opciones avanzadas para controlar el acceso y las operaciones permitidas.
### Limitación de acceso a tablas y vistas
Puedes restringir qué tablas y vistas están disponibles para el servidor MCP usando filtros de inclusión y exclusión:
```javascript
// En tu configuración personalizada (config.js)
module.exports = {
// Configuración básica...
security: {
// Sólo permitir acceso a estas tablas
allowedTables: [
'CUSTOMERS',
'PRODUCTS',
'ORDERS',
'ORDER_ITEMS'
],
// Excluir estas tablas explícitamente (tiene precedencia sobre allowedTables)
forbiddenTables: [
'USERS',
'USER_CREDENTIALS',
'AUDIT_LOG'
],
// Filtro de patrón de nombre (expresión regular)
tableNamePattern: '^(?!TMP_|TEMP_|BAK_).*$' // Excluir tablas temporales/backup
}
};
```
Para usar esta configuración:
```bash
npx mcp-firebird --config ./config.js
```
### Limitación de operaciones SQL
Puedes restringir qué operaciones SQL están permitidas:
```javascript
// En tu configuración personalizada
module.exports = {
// Configuración básica...
security: {
// Operaciones SQL permitidas
allowedOperations: ['SELECT', 'EXECUTE'], // Solo consultas y procedimientos almacenados
// Bloquear estas operaciones específicamente
forbiddenOperations: ['DROP', 'TRUNCATE', 'ALTER', 'GRANT', 'REVOKE'],
// Número máximo de filas que se pueden devolver en una consulta
maxRows: 1000,
// Tiempo máximo de ejecución para consultas (en ms)
queryTimeout: 5000
}
};
```
### Restricción de datos sensibles
Puedes configurar reglas para enmascarar o filtrar datos sensibles:
```javascript
module.exports = {
// Configuración básica...
security: {
dataMasking: [
{
// Enmascarar columnas específicas
columns: ['CREDIT_CARD_NUMBER', 'SSN', 'PASSWORD'],
pattern: /^.*/,
replacement: '************'
},
{
// Enmascarar parcialmente emails
columns: ['EMAIL'],
pattern: /^(.{3})(.*)(@.*)$/,
replacement: '$1***$3'
}
],
// Filtros de línea para excluir datos sensibles
rowFilters: {
'CUSTOMERS': 'GDPR_CONSENT = 1', // Solo mostrar clientes con consentimiento GDPR
'EMPLOYEES': 'IS_PUBLIC_PROFILE = 1' // Solo perfiles públicos de empleados
}
}
};
```
### Registro de auditoría
Configura registro detallado de todas las operaciones realizadas a través del MCP:
```javascript
module.exports = {
// Configuración básica...
security: {
audit: {
// Habilitar auditoría
enabled: true,
// Destino del log de auditoría
destination: 'database', // opciones: 'file', 'database', 'both'
// Si destination incluye 'file'
auditFile: '/path/to/audit.log',
// Si destination incluye 'database'
auditTable: 'MCP_AUDIT_LOG',
// Nivel de detalle
detailLevel: 'full', // 'basic', 'medium', 'full'
// Qué registrar
logQueries: true,
logResponses: true,
logParameters: true
}
}
};
```
### Ejemplo de registro de auditoría
```sql
-- Estructura de tabla para auditoría
CREATE TABLE MCP_AUDIT_LOG (
LOG_ID INT NOT NULL PRIMARY KEY,
TIMESTAMP TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
CLIENT_INFO VARCHAR(255),
OPERATION_TYPE VARCHAR(50),
TARGET_OBJECT VARCHAR(100),
QUERY_TEXT BLOB SUB_TYPE TEXT,
PARAMETERS BLOB SUB_TYPE TEXT,
AFFECTED_ROWS INT,
EXECUTION_TIME INT,
USER_IDENTIFIER VARCHAR(100),
SUCCESS BOOLEAN
);
-- Ejemplo de registro
INSERT INTO MCP_AUDIT_LOG (
LOG_ID, CLIENT_INFO, OPERATION_TYPE, TARGET_OBJECT,
QUERY_TEXT, PARAMETERS, AFFECTED_ROWS,
EXECUTION_TIME, USER_IDENTIFIER, SUCCESS
) VALUES (
NEXT VALUE FOR SEQ_AUDIT_LOG, 'Claude/agent', 'SELECT', 'CUSTOMERS',
'SELECT CUSTOMER_NAME, CITY FROM CUSTOMERS WHERE REGION = ?',
'["East"]', 24, 45, 'claude-session-123', TRUE
);
```
### Limitación por volumen de datos
Configura límites para evitar consultas que consuman demasiados recursos:
```javascript
module.exports = {
// Configuración básica...
security: {
resourceLimits: {
// Límite de filas por consulta
maxRowsPerQuery: 5000,
// Límite de tamaño de resultados (en bytes)
maxResponseSize: 1024 * 1024 * 5, // 5 MB
// Límite de tiempo de CPU por consulta (ms)
maxQueryCpuTime: 10000,
// Límite de consultas por sesión
maxQueriesPerSession: 100,
// Intervalo de limitación (consultas por minuto)
rateLimit: {
queriesPerMinute: 60,
burstLimit: 20
}
}
}
};
```
### Integración con sistemas de autorización externos
MCP Firebird se puede integrar con sistemas de autorización externos para un control de acceso más preciso:
```javascript
module.exports = {
// Configuración básica...
security: {
authorization: {
// Usar un servicio de autorización externo
type: 'oauth2',
// Configuración para OAuth2
oauth2: {
tokenVerifyUrl: 'https://auth.example.com/verify',
clientId: 'mcp-firebird-client',
clientSecret: process.env.OAUTH_CLIENT_SECRET,
scope: 'database:read'
},
// Mapeo de roles a permisos
rolePermissions: {
'analyst': {
tables: ['SALES', 'PRODUCTS', 'CUSTOMERS'],
operations: ['SELECT']
},
'manager': {
tables: ['SALES', 'PRODUCTS', 'CUSTOMERS', 'EMPLOYEES'],
operations: ['SELECT', 'INSERT', 'UPDATE']
},
'admin': {
allTablesAllowed: true,
operations: ['SELECT', 'INSERT', 'UPDATE', 'DELETE']
}
}
}
}
};
```
### Ejemplos prácticos de seguridad
#### Ejemplo 1: Servidor MCP para análisis de ventas
```javascript
// config-sales-analysis.js
module.exports = {
database: process.env.FIREBIRD_DATABASE,
user: process.env.FIREBIRD_USER,
password: process.env.FIREBIRD_PASSWORD,
security: {
// Acceso limitado a tablas de ventas
allowedTables: [
'SALES', 'PRODUCTS', 'CUSTOMERS', 'REGIONS',
'SALES_TARGETS', 'PRODUCT_CATEGORIES'
],
// Solo permitir consultas SELECT
allowedOperations: ['SELECT'],
// Enmascarar datos sensibles de clientes
dataMasking: [
{
columns: ['CUSTOMER_EMAIL', 'CUSTOMER_PHONE'],
pattern: /^.*/,
replacement: '[REDACTED]'
}
],
// Límites de recursos
resourceLimits: {
maxRowsPerQuery: 10000,
maxQueryCpuTime: 5000
}
}
};
```
Claude Desktop config:
```json
{
"mcpServers": {
"mcp-firebird-sales": {
"command": "npx",
"args": [
"mcp-firebird",
"--config",
"C:\\config\\config-sales-analysis.js"
]
}
}
}
```
#### Ejemplo 2: Servidor MCP para gestión de inventario
```javascript
// config-inventory.js
module.exports = {
database: process.env.FIREBIRD_DATABASE,
user: process.env.FIREBIRD_USER,
password: process.env.FIREBIRD_PASSWORD,
security: {
// Acceso a tablas de inventario
allowedTables: [
'INVENTORY', 'PRODUCTS', 'WAREHOUSES',
'STOCK_MOVEMENTS', 'SUPPLIERS'
],
// Permitir operaciones de lectura y escritura limitadas
allowedOperations: ['SELECT', 'INSERT', 'UPDATE'],
// Prevenir modificación de registros históricos
rowFilters: {
'STOCK_MOVEMENTS': 'MOVEMENT_DATE > DATEADD(-30 DAY TO CURRENT_DATE)'
},
// Auditoría completa
audit: {
enabled: true,
destination: 'both',
auditFile: 'C:\\logs\\inventory-audit.log',
auditTable: 'MCP_INVENTORY_AUDIT',
detailLevel: 'full'
}
}
};
```
#### Ejemplo 3: Configuración para desarrollo y pruebas
```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: {
// En desarrollo, permitir más operaciones
allowedOperations: ['SELECT', 'INSERT', 'UPDATE', 'DELETE', 'CREATE'],
// Excluir sólo tablas críticas
forbiddenTables: ['SYSTEM_CONFIG', 'APP_SECRETS'],
// Limitar impacto de consultas pesadas
resourceLimits: {
maxRowsPerQuery: 1000,
maxQueryCpuTime: 3000,
queriesPerMinute: 120
},
// Auditoría básica
audit: {
enabled: true,
destination: 'file',
auditFile: './logs/dev-audit.log',
detailLevel: 'basic'
}
}
};
```
Estos ejemplos ilustran cómo MCP Firebird puede configurarse para diferentes casos de uso, cada uno con sus propias consideraciones de seguridad y acceso a datos.
## Integración con agentes IA
### Claude en la terminal
Puedes usar el servidor MCP Firebird con Claude en la terminal:
```bash
# Iniciar el servidor MCP en una terminal
npx mcp-firebird --database /path/to/database.fdb --user SYSDBA --password masterkey
# En otra terminal, usar anthropic CLI con 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 "Analiza la estructura de mi base de datos Firebird"
```
### Otros agentes 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 implementa las siguientes medidas de seguridad:
- Validación de entradas con Zod
- Sanitización de consultas SQL
- Manejo seguro de credenciales
- Prevención de inyección SQL
- Limitación de operaciones destructivas
## Depuración y solución de problemas
Para habilitar el modo de depuración:
```bash
export LOG_LEVEL=debug
```
### Problemas comunes
1. **Error de conexión a la base de datos**:
- Verifica las credenciales y ruta de la base de datos
- Asegúrate de que el servidor Firebird esté en ejecución
- Comprueba que el usuario tenga permisos suficientes
2. **El servidor no aparece en Claude Desktop**:
- Reinicia Claude Desktop
- Verifica la configuración en `claude_desktop_config.json`
- Asegúrate de que la ruta de la base de datos sea absoluta
3. **Problemas con STDIO**:
- Asegúrate de que la salida estándar no esté siendo redirigida
- No utilices `console.log` para depuración (usa `console.error`)
## Licencia
MIT