MCP Firebird

Instructions

Implementation Reference

• src/tools/database.ts:82-84 (schema)

  Zod schema defining the input for the describe-table tool: requires a tableName string.

  export const DescribeTableArgsSchema = z.object({
      tableName: z.string().min(1).describe("Name of the table to describe")
  });

• src/tools/database.ts:209-238 (registration)

  Registration of the 'describe-table' MCP tool within setupDatabaseTools(), including the inline handler function that calls describeTable() from db/queries.ts and formats the response.

  tools.set("describe-table", {
      name: "describe-table",
      description: "Gets the detailed schema (columns, types, etc.) of a specific table.",
      inputSchema: DescribeTableArgsSchema,
      handler: async (args: z.infer<typeof DescribeTableArgsSchema>) => {
          const { tableName } = args;
          logger.info(`Describing table: ${tableName}`);
  
          try {
              const schema = await describeTable(tableName);
              logger.info(`Schema obtained for table ${tableName}, ${schema.length} columns found`);
  
              return {
                  content: [{
                      type: "text",
                      text: formatForClaude({ schema })
                  }]
              };
          } catch (error) {
              const errorResponse = wrapError(error);
              logger.error(`Error describiendo tabla ${tableName}: ${errorResponse.error} [${errorResponse.errorType || 'UNKNOWN'}]`);
              return {
                  content: [{
                      type: "text",
                      text: formatForClaude(errorResponse)
                  }]
              };
          }
      }
  });

• src/db/queries.ts:355-446 (handler)

  Core implementation of describeTable function that executes the SQL query against RDB$RELATION_FIELDS and RDB$FIELDS to retrieve detailed column information for the specified table.

  export const describeTable = async (tableName: string, config = DEFAULT_CONFIG): Promise<ColumnInfo[]> => {
      // Try to load config from global variable first
      const globalConfig = getGlobalConfig();
      if (globalConfig && globalConfig.database) {
          logger.info(`Using global configuration for describeTable: ${globalConfig.database}`);
          config = globalConfig;
      }
      try {
          logger.info(`Obteniendo estructura de la tabla: ${tableName}`);
  
          if (!validateSql(tableName)) {
              throw new FirebirdError(
                  `Nombre de tabla inválido: ${tableName}`,
                  'VALIDATION_ERROR'
              );
          }
  
          // Consulta para obtener información de las columnas
          const sql = `
              SELECT
                  TRIM(rf.RDB$FIELD_NAME) as FIELD_NAME,
                  CASE f.RDB$FIELD_TYPE
                      WHEN 7 THEN 'SMALLINT'
                      WHEN 8 THEN 'INTEGER'
                      WHEN 10 THEN 'FLOAT'
                      WHEN 12 THEN 'DATE'
                      WHEN 13 THEN 'TIME'
                      WHEN 14 THEN 'CHAR'
                      WHEN 16 THEN 'BIGINT'
                      WHEN 27 THEN 'DOUBLE PRECISION'
                      WHEN 35 THEN 'TIMESTAMP'
                      WHEN 37 THEN 'VARCHAR'
                      WHEN 261 THEN 'BLOB'
                      ELSE 'UNKNOWN'
                  END as FIELD_TYPE,
                  f.RDB$FIELD_LENGTH as FIELD_LENGTH,
                  f.RDB$FIELD_SCALE as FIELD_SCALE,
                  CASE rf.RDB$NULL_FLAG
                      WHEN 1 THEN 0
                      ELSE 1
                  END as NULLABLE,
                  rf.RDB$DEFAULT_SOURCE as DEFAULT_VALUE,
                  CASE
                      WHEN EXISTS (
                          SELECT 1 FROM RDB$RELATION_CONSTRAINTS rc
                          JOIN RDB$INDEX_SEGMENTS isg ON rc.RDB$INDEX_NAME = isg.RDB$INDEX_NAME
                          WHERE rc.RDB$RELATION_NAME = rf.RDB$RELATION_NAME
                          AND rc.RDB$CONSTRAINT_TYPE = 'PRIMARY KEY'
                          AND isg.RDB$FIELD_NAME = rf.RDB$FIELD_NAME
                      ) THEN 1
                      ELSE 0
                  END as PRIMARY_KEY,
                  CAST(rf.RDB$DESCRIPTION AS VARCHAR(500)) as DESCRIPTION
              FROM RDB$RELATION_FIELDS rf
              JOIN RDB$FIELDS f ON rf.RDB$FIELD_SOURCE = f.RDB$FIELD_NAME
              WHERE rf.RDB$RELATION_NAME = ?
              ORDER BY rf.RDB$FIELD_POSITION
          `;
  
          const columns = await executeQuery(sql, [tableName], config);
  
          if (columns.length === 0) {
              logger.warn(`No se encontraron columnas para la tabla: ${tableName}`);
              throw new FirebirdError(
                  `No se encontraron columnas para la tabla: ${tableName}. Es posible que la tabla no exista.`,
                  'TABLE_NOT_FOUND'
              );
          }
  
          logger.info(`Se encontraron ${columns.length} columnas para la tabla: ${tableName}`);
  
          return columns.map((col: any) => ({
              field_name: col.FIELD_NAME,
              field_type: col.FIELD_TYPE,
              field_length: col.FIELD_LENGTH,
              field_scale: col.FIELD_SCALE !== null ? -1 * col.FIELD_SCALE : undefined,
              nullable: Boolean(col.NULLABLE),
              default_value: col.DEFAULT_VALUE,
              primary_key: Boolean(col.PRIMARY_KEY),
              description: col.DESCRIPTION || null
          }));
      } catch (error: any) {
          // Propagar el error si ya es un FirebirdError
          if (error instanceof FirebirdError) {
              throw error;
          }
  
          const errorMessage = `Error describiendo la tabla ${tableName}: ${error.message || error}`;
          logger.error(errorMessage);
          throw new FirebirdError(errorMessage, 'TABLE_DESCRIBE_ERROR', error);
      }
  };