MIPS CPU (and none of any other common one) has no "compare strings" instruction, string is not native type of CPU and the instructions deal only with native types, like words and bytes.
"String" is certain amount (either defined somewhere, or using terminator character at end of data) of consecutive characters. What is "one character" depends on used encoding, in your case (MARS simulator, and simple practice of asm programming) you can stick with the old ASCII encoding, where single character is exactly one single byte. (JFYI: with modern SW you will mostly work in UTF8 encoding, like this web page does, where single character can have different amount of bytes, depending on which glyph you encode, which makes programming any string algorithm over UTF8 encoded string lot more fun than your current task. Quite often too much fun.)
Now as the CPU registers are of "word" size, that means they are 32 bits "wide", i.e. they can hold at most 4 ASCII characters at once (4 bytes), so using registers to store whole string would allow only for very sho. str. and_ noth else. You can do that, but it's not practical (except the beq would work, because you can compare word value 0x30303030 = "0000" against 0x31313131 = "1111" with beq).
Thus most of the time while programming in MIPS beginners assembly the "strings" are following pattern: some register contains memory address pointing to the first letter of string (first byte of string), and the very last "character" of string is not any letter, but value zero, the so called "null terminator".
When you want to compare strings then, you create loop, which starts with two pointers (to the two strings = to the two first letters). Load byte from both addresses into some temporary register (i.e. loading first letter of both), compare that, against, if they differ, the strings differ. If equal, check for zero (both strings ended = they are equal). If not zero, advance both addresses by one, so they will point to the next letter, and loop to the beginning.
But in your case the user can enter only single letter, and you want to compare only single letter, so writing whole loop is sort of abundant effort, you can just load that single letter and compare that.
So reading your source from top, these lines will get my comments:
#li $a1, 2
is commented out why? You should use that to limit the syscall (I think without setting anything the default value may be zero, so no input happens). Also you may be interested into syscall(v0=12) "read character" instead of "read string", but I'm not sure how that is presented toward user in MARS (user experience related), but let's stick with service v0=8 "read string" and 2 byte long buffer.
Now after syscall returns (user did enter the letter "f"), the memory at address space will contain two bytes set by syscall: 102, 0.
li $t1, 102
Looks familiar, but difficult to read for other programmer, with MARS assembler you can use also this way of writing that number: li $t1, 'f' - the simple apostrophes tells assembler you want value of single ASCII character ('ab' is error in MARS, only single char can be used, some other assemblers may translate the 'ab' as two byte value)
Next uncommented instruction is:
syscall
And here you are asking for which MARS service? You didn't set any value in v0, nor you need any service, so if you would single step over your code in debugger, this should make no sense to you, if you reason what is going happen with each instruction.
Then comes beq $t0, $t1, fahrenheit.
At that point the t1 is equal to 'f', and t0 is equal to address of first byte of that buffer, also aliased as space symbol during compilation, which is equal to some 32 bit value, probably similar to something like 0x100000c. The values 0x100000c vs 102 certainly doesn't equal, so that beq will never jump to label fahrenheit.
To compare that first letter inside buffer, first fetch its value from memory, like lb $t2, ($t0), that loads byte value from address in t0 (advanced info: lb will sign-extend the 8 bit value to 32 bit value. Basic printable characters of ASCII are all smaller than 128, so you will not need to deal with negative values, but if letter 'f' would encode as 140, using lb to load that value into t2 would produce 32 bit value -116, not 140 ... as I wrote, basic ASCII is only 7 bit, so only positive values, which work as expected, 102 is loaded as 102).
Then you can have more success with beq $t2, $t1, fahrenheit, as now it will compare ASCII character against ASCII character.
You can also use MARS MIPS assembly pseudo instruction beq $t2, 'f', fahrenheit. MARS will compile that as two native instructions:
addi $at, $zero, 102 # 102 = 'f', $at = $1, $zero = $0
beq $at, $t2, fahrenheit
Saving you some typing, which is good in programming, as long as it makes sense while reading (once you will start to shorten your source code just for the purpose of short writing, you are doing it wrong, in programming the source code is written to be being read, the writing cost is negligible compared to the reading costs). In this case beq $t2, 'f', label looks quite readable to me, so I would prefer that.
And that should be enough to answer both your questions, the explicit one (how to compare strings = in a loop, character by character), and the implicit one (how to compare that single letter from user against 'f').
beqis looking at.