Help: Tabnine keeps suggesting deprecated library methods

I've been conducting a systematic evaluation of Tabnine Pro (Enterprise plan, configured for local model execution where possible) over the past six weeks, integrating it into a mature Python/PostgreSQL/Go microservices codebase. A persistent and significant issue has emerged: the tool frequently suggests method calls and library functions that have been officially deprecated, often for several major library versions. This is not a minor nuisance; it introduces tangible technical debt and potential security vulnerabilities if uncritically accepted.

The problem appears most acute in the following contexts:
* **Python's `collections` module:** Suggestions for `collections.Iterable` and `collections.Callable` instead of `collections.abc.Iterable` and `collections.abc.Callable` (deprecated since Python 3.3, removed in 3.9).
* **SQLAlchemy 1.4/2.0:** Continued suggestions for the legacy 1.x query API when we have explicitly enabled 2.0 style with `future=True` engine configuration.
* **`datetime` `utcnow()` & `utcfromtimestamp()`:** Despite PEP 636 deprecating these in favor of timezone-aware objects.
* **`pandas` methods:** Such as suggesting `.append()` for DataFrames, which is deprecated in favor of `pd.concat()`.

My analysis suggests the issue is not random. The suggestions often correlate with high-frequency patterns in older, public GitHub repositories that likely form a substantial part of the training corpus. The model seems to prioritize statistical likelihood of a token sequence over the contextual metadata of "deprecation" which is often found in documentation text, not code examples.

I've attempted the following mitigation strategies with limited success:
1. **Project-level configuration:** Explicitly setting language versions in `tabnine_config.json`.
```json
{
"version": "3.0.0",
"language_context": {
"python": {
"language_version": "3.10",
"third_party_dependencies": ["sqlalchemy>=2.0.0", "pandas>=2.0.0"]
}
}
}
```
2. **Prompt engineering:** Attempting to prefix comments like `# Using SQLAlchemy 2.0 style. Do not use legacy Query API.` has inconsistent results.

My primary questions for the community are:

* Has anyone developed a reproducible method to suppress deprecated API suggestions, either through configuration, training on a curated subset, or prompt patterns?
* Is this behavior materially different between the local models (e.g., `codellama`) and the cloud-based completions? My early data suggests the cloud model is slightly better but still problematic.
* From an architectural standpoint, how could a code completion model best integrate official library documentation (like Python's `__deprecated__` decorator or Rust's `#[deprecated]` attribute) to down-rank or annotate such suggestions? Is this a training data problem or a runtime filter problem?

The core challenge is that the suggestion is often *syntactically* and *contextually* correct, making it a silent issue. It passes a cursory review but fails future compatibility and static analysis checks. I'm interested in collaborative data gathering on this front to see if patterns exist across ecosystems.