So, JSON API has slightly different (but complementary) goals from the documentation tools you mentioned, and it can be used in combination with them.
Basically, JSON API’s goal is to impose a common structure on APIs (e.g. to say “all APIs that support including related resources should do it this way”). This helps API authors by offering them well-thought-out patterns for supporting common features, so they don’t have to reinvent the wheel. And, it helps API users by making their knowledge more transferable. (If a developer’s used one JSON:API API, they already know a lot about how to use another, even without looking at its docs.)
Also, JSON API allows for client developers to use existing libraries to consume the API. This is similar to how Swagger et al can generate a client library for a given API based on its documentation—though with a JSON:API API the API author has to do less work upfront documenting things, and the resulting client will have a more predictable (and perhaps better tailored) interface, since the only thing that varies from one JSON:API API to the other are the models (for the most part).
A JSON:API API can still be documented with Swagger et al, for people who want the benefits of those formats, or it can be documented more simply, just by describing what’s unique about it and referring people to the JSON API specification for the rest.
Finally, there may be certain semantics that a JSON:API API expresses that can’t be communicated with Swagger et al to machines. For instance, when a JSON API error occurs, a generic client can know exactly what each field in the error object means (since those meanings are defined by the spec), and can provide default handling behavior. My understanding of Swagger et al, by contrast, is that it’s certainly possible to say “the error response’s JSON will have this shape”, but it’s not possible to express the semantics of each field in a machine readable way. And the same goes for other semantic bits in the JSON API spec, like the values of the
"links" key, each of which has a predefined, machine-knowable meaning.