Confused about whether I should use a reasoner

I'm new to the Semantic Web (but a rather seasoned developer in other areas). I am currently in the process of creating a prototype for a web application whose foundation rests on a public health OWL ontology (diseases, health determinants, indicators, etc).

As the interface of the application should be able to handle "natural language" (i.e. be a so-called NLI), I am currently working on a program to drive it using a set of SPARQL queries (basically, I apply a set of predefined queries, trying to find the best (or most specific) match for the user input).

That approach works well for the moment, but I've been having nagging doubts about whether I should eventually try to incorporate a reasoner to my project. I have an high-level understanding of what a reasoner does (i.e. follow the ontology facts and axioms to their conclusions, to identify "hidden" or non-obvious relationships) but contrary to my SPARQL queries, I don't have a practical understanding of what I'd gain by using one, or about the parts it could replace (or augment) in my current setup.

Could someone enlighten me about this? In what way could be reasoner be used in such a project, and what kind of interplay would it have with any existing SPARQL workflow? Are they even operating on the same "level"? I'm aware that my questions are rather vague, but I'll happily provide additional details if needed.

Basically all a reasoner really does is it creates extra triples. For example say you have:

ex:Person rdfs:subClassOf ex:Human .
:Luca rdf:type ex:Person .

The idea is that if you query (using SPARQL) for ?humans rdf:type ex:Human, you would like back :Luca. But SPARQL works on simple basic matching of triple patterns, and there's no :Luca rdf:type ex:Human pattern in your data. So how would the query match Luca if we didn't explicitly say that Luca was a Human?

Well the reasoner comes in and it creates the extra triples based on the reasoning it performed. For this case it would create the extra triple: :Luca rdf:type ex:Human . which is not present in your original data, and is induced by the reasoner thanks to the rdfs:subClassOf statement.

The SPARQL query can now match Luca when querying for Humans, thanks to the triples that were generated by the reasoner.

Hope this may have shed some enlightenment.