Devnors Data MCP Server: Chinese Legal, Company and Keyword Data for MCP Clients

What Devnors Data MCP actually solves

An LLM asked about a Chinese court judgment or a company's shareholders will usually answer from memory, which is either stale or invented. The fix is to give the model a tool that hits a live source. Devnors Data MCP is that tool layer: it registers roughly forty named tools on top of a hosted data service, covering legal judgment documents, current law articles, company registration details, annual reports, tax credit levels, dishonest judgment debtor checks, keyword and WeChat indices, express tracking, invoice OCR, and academic paper, patent and scholar search. The README's own examples are the clearest statement of the intended user: search Chinese legal judgment documents for private lending interest disputes, look up current PRC law articles about contract termination, check whether a company is on the dishonest judgment debtor list, suggest related keywords for "lawyer" on Baidu.

That list tells you who this is for. It is not a general web-search connector. It is aimed at people doing Chinese-market due diligence, legal research, SEO or content work, and academic literature review, who already have an MCP-capable assistant and want the assistant to fetch records rather than recall them. The project is Python, MIT licensed, and the last push to the default branch was on 2026-09-15.

Remote HTTP versus local stdio: two ways the same server runs

The architecture is deliberately thin. There are two deployment shapes. In the recommended remote HTTP shape, the client talks to https://data.devnors.com/mcp and the MCP server runs on Devnors' side; nothing is installed locally and the API Key travels in an Authorization header. In the local stdio shape, the pip package devnors_mcp runs as a subprocess of the MCP client, the key arrives through the DEVNORS_API_KEY environment variable, and the process calls the same backend over the network.

Either way the data flow is the same: client to MCP tool, MCP tool to Devnors Data HTTP API, response back as structured fields. The package depends on mcp>=1.0.0 and devnors-data>=0.1.3, so the actual HTTP client and retry logic live in the separate devnors-data Python SDK rather than in this repository. The README is explicit that retryable 429 and 5xx responses are retried by that SDK with bounded backoff and that the MCP layer does not stack extra retries. That is a sensible boundary, and it also means the interesting failure behaviour is not in this repo.

One design choice worth flagging: list_capabilities is a tool rather than a static schema. The assistant is expected to call it first to discover which domain and type combinations exist, what filters they take, and which errors they return. That keeps the tool list from going stale when the backend adds capabilities, but it costs a round trip and a billed call before any real query, and an agent that skips discovery will guess parameter names.

Installing Devnors Data MCP and running a first query

Get an API Key from the developer console at https://data.devnors.com/console first. Then pick one of the two transports. For remote HTTP, no Python install is required; the README gives this client configuration:

{
  "mcpServers": {
    "devnors-data": {
      "url": "https://data.devnors.com/mcp",
      "headers": {
        "Authorization": "Bearer devnors_sk_live_xxx"
      }
    }
  }
}

Replace devnors_sk_live_xxx with the key from the console and restart the client. The server should appear in the client's tool list; if it does not, the key or the URL is wrong, since unauthorized is the error the API returns for a missing or invalid key.

For local stdio, install the package and point the client at the module rather than the script:

pip install devnors-mcp

{
  "mcpServers": {
    "devnors-data": {
      "command": "python",
      "args": ["-m", "devnors_mcp.server"],
      "env": {
        "DEVNORS_API_KEY": "devnors_sk_live_xxx"
      }
    }
  }
}

On Windows the README warns that the client PATH often cannot find the devnors-mcp entry point, and recommends the python -m form above or an absolute path to the Python interpreter.

Once connected, the first useful call is discovery, not a data query. Ask the assistant to list available Devnors Data capabilities and required filters. That should return the live domain and type catalogue with the filters each one accepts. From there a concrete call looks like the README's example prompts, for instance checking whether a company is on the dishonest judgment debtor list. Successful calls return units and request_id, so you can reconcile usage against the console.

Billing, error codes and the retry boundary

Every successful call reports units, which is a billing quantity rather than a diagnostic. The README states that WeChat Index v2 is billed per keyword, which is the one place it spells out a pricing unit; the rest of the catalogue is described only as consuming units. Treat the tool list as a menu with prices attached, and check the console before letting an agent loop over it.

The error table is the part of this project that is better designed than most API wrappers. Failures carry a code and a retryable flag so the agent can decide what to do without a human: unauthorized and insufficient_balance are not retryable, rate_limited, unavailable and upstream_error are, invalid_capability means the domain or type was wrong, and not_implemented marks a capability that is planned but not live. The insufficient_balance case points at https://data.devnors.com/console/recharge. An agent that reads retryable correctly will back off on a 429 and stop dead on a 401, which is exactly the behaviour you want and is not universal in MCP servers.

Where Devnors Data MCP is the wrong choice

The first limitation is structural: this is a client for a commercial API, not a data source. There is no bundled dataset, no local index and no offline mode. If the backend is unavailable, every tool except discovery fails, and the failure is upstream_error rather than something you can fix locally. The README does not document any caching layer, so repeated identical queries are repeated billed calls.

The second is the not_implemented code. Its presence in the error table means the published tool list includes capabilities that are planned rather than working. An agent that picks a tool by name from the table may hit a placeholder. Discovery through list_capabilities is the documented way around this, but it means the static table in the README should not be treated as a contract.

The third is scope. The catalogue is heavily weighted toward Chinese-language sources: judgment documents, PRC law articles, the national enterprise credit system, Baidu and WeChat keyword indices. If your research is in English and does not touch Chinese entities, this server adds a paid dependency for data you can get elsewhere. There is also no homepage field on the repository, and the README does not document rollback of a configuration change or a way to revoke a key other than through the console, so plan key rotation around the console rather than the client config.

Finally, the local stdio path inherits the Python version floor from pyproject.toml: requires-python is >=3.10. On an older interpreter the install will fail before any of this matters.

How this differs from a general web-search MCP server

The obvious alternative for an agent that needs facts is a general web-search connector, and the README itself lists cloud_web_search as one of the tools here, so the comparison is not either/or. The difference is in what the two return. A web-search tool returns pages and snippets, and the model then has to read them and decide what is true. A structured tool such as enterprise_breach_of_trust returns a record with defined fields for a specific company, which the model can pass on without interpretation.

That distinction matters for anything resembling compliance or due diligence work. Searching the web for whether a company is a dishonest judgment debtor produces news articles and forum posts. Calling the dedicated tool produces the registry answer, or a structured error if the query is malformed. The cost of that precision is the API Key, the per-call units, and the fact that the answer is only as current as the upstream source, which the README does not date.

If you want a self-contained alternative rather than a hosted one, the honest answer is that this repository does not offer one. The Python SDK at devnors-data-python is the same service through a different interface, not a different data source.

Licence and upgrade cost

The repository is MIT licensed, and pyproject.toml declares license = { text = "MIT" } with a LICENSE file at the top level. MIT covers the wrapper code: you can fork it, vendor it, or modify the tool definitions. It does not cover the data. The API Key, the per-call units and the console account are a separate commercial relationship governed by the service's terms, not by the repository licence. Nothing in the README suggests the data itself is redistributable, so do not read the MIT licence as permission to cache and republish API responses.

Upgrade cost is low on the wrapper side. There are no retrieved releases for this repository, so versioning is dynamic from devnors_mcp.__version__, and the dependency floor on devnors-data>=0.1.3 means a pip upgrade can pull a newer SDK with different retry behaviour. Since the MCP layer deliberately does not add its own retries, a change in the SDK's backoff policy is a change in how your agent behaves under load. Pin devnors-data in your own environment if that matters. The last push to main was on 2026-09-15, so the repository is moving, but there is no changelog to tell you what moved.

Editorial conclusion

Adopt Devnors Data MCP if you already pay for a Devnors Data API Key and want Chinese legal, enterprise or keyword lookups inside an MCP client without writing an HTTP client. Do not adopt it if you need an offline or self-contained dataset, if your queries are English-language web research, or if you cannot top up the account, because every tool call except discovery is billed. Before wiring it into a workflow, verify two things: that your client supports remote HTTP with an Authorization header, and that a single call to list_capabilities returns the domain and type you actually need rather than a not_implemented placeholder.

Frequently asked questions

Official sources

1. DevnorsAI/devnors-data-mcp on GitHub
2. Issues
3. License: MIT
4. README