DepTime
DepTime is an MCP server for diagnosing Python library breakage and checking API compatibility across releases.
Explain errors: Parse import, attribute, module, or signature tracebacks to identify what changed, when, deprecation messages, replacement candidates, and a version pin that restores the old API.
Inspect symbol history: Get the first/last release a public symbol existed, signature changes, deprecations, removals, and replacement candidates.
Preflight code: Check symbols and keyword arguments against a specific package version, optionally by passing Python code, and get present/missing/unknown status, rejected kwargs, missing required args, and deprecation notes.
Diff versions: Find breaking changes and deprecations between two versions or since a date, optionally filtered to symbols your code uses.
Check coverage: List indexed packages and version ranges, and see whether DepTime can answer about a given package at all.
Stay evidence-based: Answers include confidence and evidence, and return “not covered” or
unknownrather than guessing when it cannot tell.
Indexes PyPI package releases and their public APIs to provide version history, breaking-change and deprecation diffs, symbol compatibility checks, and traceback-based error explanations for Python libraries.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@DepTime what changed in httpx between 0.27.2 and 0.28.1?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Python libraries rename and remove things between releases. Code that worked last year, or code an AI model learned from, then fails with an ImportError, an AttributeError or "unexpected keyword argument". DepTime tells a coding agent what changed, in which release, and what to use instead, in one call. It also checks a dependency update against your code and names each line the new version breaks: on a pull request, from a terminal, or in one call.
Computed, not remembered. Each answer comes from comparing the library's own source across its releases, not from docs or a model's memory, and it quotes the evidence it found.
Local and free. Open source (MIT). Your code and errors never leave your machine.
Says when it doesn't know. For a package it doesn't cover, or a name it can't follow, the answer is "not covered" or
unknown, never a guess.
Status: alpha. 0.2.0 adds the upgrade check below. The index rebuilds itself twice a day, and fixes follow reported wrong answers. Known gaps are listed in BACKLOG.md.
Check a dependency update
On a pull request from Dependabot, Renovate or a person, the GitHub Action finds the lines of your Python code the new versions break, annotates each one, and fails the check only on a confirmed break (docs):
# .github/workflows/upgrade-check.yml
on:
pull_request:
paths: ["**/uv.lock", "**/poetry.lock", "pyproject.toml", "**/requirements*.txt", "**/requirements/**"]
permissions:
contents: read
jobs:
check:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7 # pin to a commit in your own workflows
- uses: cschmertz/deptime@v0.2.2From a terminal, uvx deptime check-upgrade compares the pinned versions at HEAD with your working tree, or --package httpx --to 0.28.1 checks one update. An agent can call the check_upgrade tool with the code instead, and the Claude Code plugin's /deptime:fix-upgrade runs the check and has Claude fix the lines it reports as broken and check the ones it can't tell about. A break is a use the index shows failing at the new version and not at the old one; the report ends with a block a coding agent can act on.
On 264 real Dependabot and Renovate update pull requests (247 projects, scored once before any fix, results), the check failed all 13 whose update breaks the project's code, found 46 of the 48 breaking uses, and flagged 1 of 3,291 uses that still work. 2 of the 264 failed with no real break.
An agent fixing the breaks (Claude Code on Sonnet 5.5, 25 real broken updates, results): alone it left the code working in 80% of sessions; with /deptime:fix-upgrade in 64%, in a third of the turns; with the plugin installed and not named, 80%. On 66 new broken updates (results), the reworked command: 72.7% against 69.7% alone, in about half the turns. It is being improved and measured again on new updates before 1.0.
Related MCP server: FreshStack MCP
Install
Requires uv.
# Claude Code. Cursor, Codex, VS Code and Claude Desktop take the same
# command (uvx deptime mcp) in their MCP config.
claude mcp add deptime -- uvx deptime mcpOn first launch DepTime downloads its prebuilt index (one file from this repo's GitHub Releases) in the background, then checks for a newer one at most once a day. Set DEPTIME_OFFLINE=1 to never touch the network. Each index carries a signed record of the CI run that built it; deptime index pull --verify checks it (SECURITY.md).
Claude Code users can also install the plugin in integrations/claude-code with /plugin marketplace add cschmertz/deptime, then /plugin install deptime@deptime. It adds a skill, the /deptime:fix-upgrade command, and a local hook that suggests DepTime when a Python version-change error appears in a command's output.
First launch timing out? uvx installs DepTime the first time a client starts it. On macOS with an x86_64 uv (an Intel Mac, or Intel Homebrew on Apple silicon), one dependency, cryptography, has no prebuilt wheel and is compiled, which can take longer than a client waits for a server to start. Run uvx deptime --help once beforehand.
Client compatibility
Checked 2026-11-05 with deptime 0.1.4 (details):
Client | Result |
Claude Code 2.1.318 | ✅ |
Codex CLI 0.166.0 | ✅ |
MCP Python SDK clients 1.0–1.30 and TypeScript SDK clients 1.0–1.32 (protocols 2024-11-05 to 2025-11-25), over stdio and against | ✅ |
Cursor, VS Code, Claude Desktop | not checked yet; they take the same |
What an answer looks like
An agent that hits this error:
TypeError: Client.__init__() got an unexpected keyword argument 'proxies'passes it to explain_error and gets:
{
"symbol": "httpx.Client.__init__(proxies)",
"issue": "param_removed",
"installed_version": "0.28.1",
"last_version_with": "0.27.2",
"first_version_without": "0.28.0",
"deprecated_in": "0.26.0",
"replacements": [
{"target": "proxy", "confidence": 0.8, "source": "deprecation_message"},
{"target": "mounts", "confidence": 0.79, "source": "deprecation_message"}
],
"pin_to_restore": "httpx<=0.27.2",
"confidence": "high"
}That's the real answer from the published index, trimmed. The full answer also quotes the deprecation message DepTime found in httpx's own source, and adds a one-sentence explanation for the agent to pass on:
httpx.Client.init accepted
proxiesup to httpx 0.27.2; it is gone from 0.28.0 onward. Deprecated in 0.26.0 ("The 'proxies' argument is now deprecated. Use 'proxy' or 'mounts' instead."). Useproxyormountsinstead, or pin httpx<=0.27.2.
Tools
Tool | Use it when |
| An import or call into a library just failed |
| Before trusting an API you remember |
| Pre-flight check of the symbols and kwargs you're about to use |
| Upgrading, or "what changed since my training cutoff?" |
| Updating a dependency: the lines of your code the new version breaks |
| What's indexed (53 fast-moving packages: AI/agent stack + libraries with known breaking changes; list) |
Every answer carries evidence and a confidence level. The contracts are in docs/03-product-spec.md.
How well it works
Every DepTime number in the table is a first run: the cases and their right answers were collected and committed before DepTime ever ran on them.
How often does it… | First run | Measured on |
find the right package, name and breaking release from a real traceback? | 87% (166 of 191) | Tracebacks from GitHub issues and Stack Overflow, in six sets |
…and a language model alone, answering the same tracebacks from memory with no tools? | 82% to 84% (Claude Sonnet 5.5 and Opus 5.5), 66% to 69% (Haiku 5.5), 59% (DeepSeek V4.1 Flash), 19% (Qwen3.5 9B) | The same 191, scored the same way. The larger models name the change and its replacement more often than DepTime, and the release less often |
offer the right replacement among its first three suggestions? | 48% (41 of 85) | The same tracebacks, where a replacement is known |
flag code that still works after an upgrade? (lower is better) | 0.1% (2 of 2,047) | Uses of covered packages in real projects, labelled by running them. Newest of six sets; the oldest scored 3.8% |
find the code that an upgrade breaks? | 100% (147 of 147) | The same projects. Newest set; the six range from 95.9% to 100% |
…and a language model alone, judging the same uses from memory? | Breaks found and working code flagged: 91% and 0.2% (Sonnet 5.5), 74% and 0.3% (Haiku 5.5), 81% and 2.7% (DeepSeek V4.1 Flash), 31% and 15% (Qwen3.5 9B) | The same 2,265 uses, one run per model, scored the same way, counting |
The upgrade checks are the strong part. The last two rows are
check_symbols. On the same set,diff_versionsfound 96.7% of the breaks (147 of 152) and flagged 0.1% of working code (2 of 2,113).The smaller the model, the more DepTime adds. Claude Opus and Sonnet alone come within a few points of it. Haiku, DeepSeek V4.1 Flash and Qwen3.5 9B fall 18 to 68 points behind on the tracebacks, and on the upgrade checks the two cheaper ones flag 2.7% and 15% of working code, against DepTime's 0.1%. Given DepTime's tools, Qwen3.5 9B still flags 3.5% to 4.5% (results): to get DepTime's precision, run its check rather than have a small model judge each use.
Replacements are the weak part. On unseen errors the right one is offered about half the time, where the Claude models in the second row offer it 87% to 99% of the time. A suggestion at confidence 0.75 or more is usually right: 11 of 11 on the first run over 50 documented migrations, 42 of 45 now.
The same cases score higher today (97.2% of all 393 real tracebacks in the benchmark), because fixes were designed from their misses. That is why the first run is the number to trust.
Where it can't tell, it says so.
check_symbolsansweredunknown, with the reason, for 66 working uses and 5 breaks of the newest set, which are left out of its rates above.
Every set, every later re-run and each miss is in bench/README.md. CI re-scores all of it on every code change and every published index, and fails on a drop of more than 2 points.
What it doesn't do
It covers the packages on its list, not all of PyPI, and every release of each minor series active since 2023. For anything else the answer is "not covered".
It reads source without running it. A name that only exists once the library is running (built by compiled code, or computed at import time) can read as
unknown, or occasionally as missing.It sees names, parameters and deprecations, not behaviour. A function that keeps its signature but changes what it does is invisible to it, so a clean upgrade check doesn't replace your tests.
Python only.
How it works
Twice a day, GitHub Actions reads each new release's public API with griffe, which parses the source without running it, diffs it against the previous release, and publishes the result as one file, index.sqlite.xz, on this repo's Releases. On your machine, deptime mcp checks that file's sha256 and schema before swapping it in, then answers every question locally in milliseconds. The full design is in docs/04-architecture.md, and the decisions are in docs/adr/.
CLI
uvx deptime explain --installed httpx==0.28.1 < traceback.txt
uvx deptime history httpx Client.__init__
uvx deptime check httpx 0.28.1 'httpx.Client:proxies,proxy'
uvx deptime diff httpx 0.27.2 0.28.1
uvx deptime diff pydantic 2024-06-01 # everything since a date
uvx deptime check-upgrade # what the lockfile change breaks; exit 1 on a break
uvx deptime index status | pullHosting (optional)
Local mode covers coding agents. For web clients that only accept a URL, run deptime serve (MCP at /mcp, JSON at /v1/*) on any container host. The repo includes a Dockerfile and fly.toml, and the server applies anonymous rate limits. See docs/05-self-hosting.md.
Prior art and credits
griffe does the static analysis.
since-cutoff diffs your pinned dependencies against a model's training cutoff, locally and on demand. DepTime differs by shipping a prebuilt cross-version index and starting from a traceback.
Context7 and Ref serve version-specific docs. DepTime answers symbol-level "when and what replaced it" questions.
Contributing
The most useful contributions are wrong-answer reports, which become benchmark cases. See CONTRIBUTING.md. Development setup:
uv sync && uv run pytest
# build a small local index from real PyPI wheels
uv run deptime ingest httpx --versions 0.27.2 0.28.1Docs
Product spec · Architecture · Self-hosting · Risks & spikes · Privacy & security · Benchmark · Changelog
License
Available Tools
6 toolscheck_symbolsCheck symbols and kwargs against an installed versionARead-onlyIdempotent
Batch-check that symbols, and the keyword arguments you plan to pass, exist in a specific version of a package. Returns present/missing per symbol (unknown where the index can't tell, with the reason), rejected kwargs, deprecation notes, and hints. Use it to preflight code against the version you have installed: pass the symbols, or the code itself. For one symbol across all releases use symbol_history, and after an exception use explain_error.
Inputs: package (required), version (required), code, symbols. Returns: note, exact, package, results, +2 more
check_upgradeWhat a dependency update breaks in your codeARead-onlyIdempotent
Call this before or after updating a dependency: pass the package, the version you have, the version you are moving to, and the code that uses the package (a snippet, or several files by path). Returns each use the new version breaks, with its file and line: a removed name, a keyword no longer accepted, a newly required argument, or a call that only raises, with the release that changed it and the replacement. A break is reported only when the new version fails and the old one doesn't; deprecations are warnings, and uses DepTime can't tell about are listed apart, never as breaks. One package per call; for a whole project, deptime check-upgrade reads the version changes from its lockfiles.
Inputs: package (required), from_version (required), code, files, +1 more. Returns: base, note, breaks, checked, +6 more
coverageWhat DepTime indexesARead-onlyIdempotent
Lists indexed packages and version ranges. If a package is missing, DepTime cannot answer about it. Takes no arguments; call it first when unsure whether a package is covered.
Inputs: no named parameters. Returns: policy, packages, index_built_at, configured_but_not_indexed
diff_versionsBreaking changes between versionsARead-onlyIdempotent
Breaking changes and deprecations of a package between two versions, or since a date such as your training cutoff ('YYYY-MM-DD'). Optionally restrict to the symbols your code uses. Most severe first. Use it when upgrading, or for code written against an older release; for a single symbol use symbol_history.
Inputs: package (required), from_version (required), limit, to_version, +2 more. Returns: note, events, package, truncated, +4 more
explain_errorExplain a Python import/attribute/signature errorARead-onlyIdempotent
Call this when a third-party Python library raises ImportError ('cannot import name'), ModuleNotFoundError, AttributeError ('has no attribute'), or TypeError ('unexpected keyword argument' / 'missing required argument'). Returns what changed, in which release, the deprecation message, replacement candidates with evidence, and the version pin that restores the old API. Pass installed versions for an exact answer. An error DepTime can't explain returns empty findings rather than a guess; check note and not_covered.
Inputs: traceback (required), pip_freeze, min_confidence, installed_versions. Returns: note, signal, findings, suppressed, +2 more
symbol_historyVersion history of one symbolARead-onlyIdempotent
Version history of one public symbol, e.g. package='httpx', path='httpx.Client.init': first and last release it exists in, signature changes, deprecations, removals, and replacement candidates. Use before writing code against an API you remember from training data. A path no indexed release has is not an error: it returns ever_seen=false. For many symbols at one installed version, use check_symbols.
Inputs: path (required), package (required). Returns: note, path, events, indexed, +10 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Most tools have clearly distinct roles: coverage checks indexed packages, explain_error handles runtime exceptions, and check_upgrade validates code against a target version. There is some overlap between check_upgrade and diff_versions, and between check_symbols and symbol_history, but the descriptions explicitly cross-reference each other to guide selection.
The names mix conventions: two use check_ + noun, two use verb_noun, one is a bare noun (coverage), and one is noun_noun (symbol_history). The names are still readable and domain-specific, but there is no predictable pattern across the set.
Six tools is well-scoped for a dependency and API compatibility checking server. Each tool covers a distinct query type (coverage, upgrade breaks, symbol checks, version diffs, runtime errors, symbol history) without obvious redundancy.
The surface covers the full workflow: checking package coverage, preflighting symbols, comparing versions, validating code during upgrades, explaining runtime import/attribute/type errors, and inspecting symbol history. No obvious lifecycle gap remains for the stated dependency compatibility domain.
Maintenance
Related MCP Connectors
Dated, verified API breakages for coding agents, plus a local scan for them in your existing code.
Check exact npm/PyPI upgrades for evidence-backed breaking changes; query APIs and components.
Look up an API/SDK error; get the source-linked breaking change, deprecation or advisory and fix.
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables AI agents to index local Python repositories and retrieve code intelligence through semantic search, caller lookups, hybrid context expansion, and visualization.5MIT
- AlicenseAqualityCmaintenanceEnables AI coding agents to inspect project dependency versions, resolve version constraints, and audit Python code for deprecated or incompatible APIs using authoritative evidence and local AST analysis.332 npmMIT
- AlicenseAqualityBmaintenanceProvides a local, version-exact API index for installed Python and TypeScript packages, enabling accurate lookups and static code checking that catches hallucinated or misused APIs without executing the code.9MIT
- AlicenseNot gradedqualityBmaintenanceEnables coding agents to query breaking API changes in dependencies since a model's training cutoff, retrieve project dependency change summaries, and look up model training cutoff dates.35 PyPI10MIT