Note that a context-free grammar can be ambiguous. Context-free does not mean "unambiguous".
Therefore, when the CFG gives us a yes-or-no answer, it is possible that the given string of symbols is in the language in more than one way: two or more different parses are possible using the same CFG, both of which confirm that the string is valid syntax.
To know which parse was used, we need the abstract syntax tree. (Or some other object, such as information representing the detailed trace of the parsing steps.)
Of course, we need the syntax tree for other purposes also, but the first thing that it gives us is how the syntax was interpreted: how the symbols group together and subordinate. If the string was
A + B * C, the parse tree tell us whether the interpretation was
(A + B) * C or
A + (B * C).
Before we can interpret meaning, we must interpret syntax. (However, we don't have to interpret all the syntax before interpreting any of the meaning. Compilers do some interpretation of meaning on what was already parsed, which guides the parsing decisions for what is yet to come.)
Note that parse tree and abstract syntax tree are two related but different ideas. A parse tree is concerned with the raw syntax, and so it includes punctuation tokens. Parse trees are relatively uninteresting in compilers for programming languages; it is not useful for a compiler's parser to output a parse tree, other than for debugging the low level actions of the parser: is it doing the right things with semicolons, commas, parentheses, and such. What we want is an abstract syntax tree.
(In fact, some of the syntax will even disappear before tokenization: for instance, comments may disappear, and serve only to divide two tokens, like
a/*...*/b in the C language, producing two tokens. So parse trees, chock full of irrelevant details though they be, do not have all the irrelevant details.)
The abstract syntax tree identifies the meaningful symbols in the utterance and their relation to each other: which feature of the sentence is the major constitutent, and which are its subordinates. For instance, the abstract syntax tree of
A * (B + C) will tell us that this is a multiplicative expression: the root node is the
* operator, and its children are
A, which is a leaf-node, and
(B + C) which is subtree consisting of the
+ node and the children
C. The semantic actions in the parser know which parts of a phrase carry meaning and which are just punctuation marks; they pull out the meaningful pieces out of the syntax to build the tree.
In an abstract syntax tree, furthermore, what used to be raw tokens in the syntax may be replaced by richly typed objects. In a given language, a token whose lexeme looks like
123 may become an integer object in the tree; a token which looks like
abc may turn into a symbol object, and
"xyz" into a string and so forth.