QWED-MCP
OfficialA local MCP server that lets Claude run dynamically written Python scripts as a deterministic verification calculator, governed by a static allowlist admission check.
Execute Python code (
execute_python_code): run self-written scripts in a subprocess with restricted environment variables to check math, finance (compound interest, EMI), statistics, or structured-data claims exactly — usingdecimal,fractions,math,statistics,itertools,json,re, etc.Enforce an allowlist before running — modules, builtins and attributes outside the computation-only list (e.g.
os,subprocess,open,eval,getattr, private/special attributes) are refused with a stated reason and never executed.Run heavy verifications in the background (
execute_python_codewithbackground: true): returns a job ID instead of blocking.Poll results (
verification_status): fetch the status and captured output of a background verification job by its job ID.Multi-step reasoning workflows: pair Claude's reading/normalization of documents with scripted checks (e.g. extract penalty terms, then verify each stays within stated bounds).
Fully local, offline operation: verification happens on-machine with no external API calls, keys, or data storage.
Limits to note: code execution is off by default until an admin sets
QWED_MCP_TRUSTED_CODE_EXECUTION=true; admitted code runs with server privileges, output should be treated as untrusted, and admission is a static reachability check — not a correctness proof, and no memory cap.
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., "@QWED-MCP Verify the Pythagorean theorem using Z3 solver"
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.
MCP Server for QWED Verification — Bring deterministic verification to Claude Desktop, VS Code, and any MCP-compatible AI assistant.
📚 Full Documentation: docs.qwedai.tech/mcp
⚡ Quick Install
pip install qwed-mcpRelated MCP server: SymPy Sandbox MCP
🚀 Setup with Claude Desktop
Step 1: Find your config file
OS | Path |
Windows |
|
macOS |
|
Linux |
|
Step 2: Add QWED-MCP
macOS/Linux:
{
"mcpServers": {
"qwed-verification": {
"command": "qwed-mcp"
}
}
}Windows (use python -m):
{
"mcpServers": {
"qwed-verification": {
"command": "python",
"args": ["-m", "qwed_mcp.server"]
}
}
}Step 3: Restart Claude Desktop
Quit completely (system tray → Quit) and reopen.
Step 4: Test it!
Code execution is off by default: until the server administrator sets QWED_MCP_TRUSTED_CODE_EXECUTION=true in the server's environment (for example with an "env": {"QWED_MCP_TRUSTED_CODE_EXECUTION": "true"} entry next to "command" above), execute_python_code answers BLOCKED_ADMIN_POLICY and runs nothing. Admitted code then runs with the server's privileges, so only turn it on where that is acceptable.
Ask Claude:
"Write a python script that checks a 10,000 investment at 7.5% for 5 years with the
decimalmodule, and run it usingexecute_python_code."
⚠️ Migration Note: Deprecation of verify_* Tools
To solve "context bloat" and align with the new MCP standard (RFC-9728), all 1:1 functional tools (e.g., verify_math, verify_sql, verify_code) have been removed as of v0.2.1.
They have been replaced with a single, highly capable tool:
👉 execute_python_code
Before:
"Use
verify_mathto check this formula." (Claude loads 14 different tool schemas into context)
After:
"Use
execute_python_codeto write and run a script that checks..." (Claude loads 1 tool schema into context)
If you see an "Unknown tool" error, it means Claude is trying to use a legacy tool. Simply tell Claude: "The verify_* tools are removed. Use execute_python_code to natively write and run a Python verification script."
🔧 Available Tools
Tool | Description | Use Case |
| Subprocess Execution | The single tool the server registers. Executes dynamically generated Python code in a subprocess with restricted environment variables, after an allowlist admission check (below). Note: Runs with server privileges; ensure inputs are trusted. |
What code is admitted
Before any code runs, the server parses it and admits it only when every module, builtin and attribute it uses is on an allowlist (src/qwed_mcp/engines/python_allowlist.py):
Modules: computation-only standard-library modules such as
math,cmath,decimal,fractions,statistics,itertools,functools,collections,json,re,datetimeandrandom, and in each only the listed names. Modules that reach files, the network, processes, the environment or the import system (os,sys,subprocess,socket,pathlib,importlib,ctypes, ...) are refused, and so is every third-party package, QWED SDK packages included.Builtins: only builtins that compute.
open,eval,exec,compile,__import__,getattr,vars,globals,type,input,breakpointand the rest are refused wherever they appear, so they cannot be rebound or passed on.Attributes: no special or private attribute (
__x__,_x) apart from reading__init__and__name__, no frame or traceback attribute, andstr.formatonly on a string literal whose fields read no attribute.
Admission is a static check of what the code can reach. It is not a proof that the code is correct, and it does not limit resource use: the execution timeout limits run time, and nothing limits memory. Refused code is reported with the reason and never runs. The output of admitted code comes from that code, so treat it as untrusted data.
💡 Example Prompts for Claude
Note: Claude already knows how to use QWED natively via standard Python imports.
Financial Calculations
A bank says: "Invest $10,000 at 7.5% compounded quarterly for 5 years = $14,356.29"
Please write a short Python script using the standard compound interest formula to verify this, and run it with execute_python_code.Loan EMI Verification
Verify: ₹10,00,000 loan at 9% for 5 years = EMI of ₹20,758
Write a python script importing necessary tools to verify this EMI calculation, and execute it using execute_python_code.Complex Reasoning Workflows (The Power of Python)
Read the user terms in the attached document.
1. Extract the financial penalties the terms state.
2. Use execute_python_code to check that each penalty stays within the stated boundaries.🏗️ How It Works
┌───────────────────────────────────────────┐
│ Claude Desktop / VS Code │
│ (MCP Client) │
└─────────────────┬─────────────────────────┘
│ MCP Protocol (JSON-RPC)
▼
┌───────────────────────────────────────────┐
│ QWED-MCP Server │
├───────────────────────────────────────────┤
│ execute_python_code() │
│ └─► Subprocess Execution (Restricted Env)│
│ └─► Allowlist admission, then run │
└───────────────────────────────────────────┘🎯 Why QWED-MCP?
Note: Subprocess execution provides answers/checks purely based on what the executed scripts compute. Execution itself does not guarantee injection detection. QWED SDK packages are not on the admission allowlist yet, so scripts that import them are refused (see What code is admitted).
Without QWED-MCP | With QWED-MCP |
LLM calculates in its reply → may slip or round | Script computes it with |
LLM writes code → might reach files, network or processes | Code is checked against the allowlist first → refused before it runs |
💡 What QWED-MCP Is (and Isn't)
✅ QWED-MCP IS:
MCP Server that adds verification tools to Claude Desktop and VS Code
Deterministic — uses SymPy (math), Z3 (logic), AST (code) for exact verification
Open source — works with any MCP-compatible AI assistant
A safety layer — catches LLM hallucinations in real-time
❌ QWED-MCP is NOT:
A replacement for Claude— it enhances Claude with verification toolsA chatbot— it's a backend server that Claude callsInternet-connected— all verification happens locallyA fine-tuned model— uses symbolic engines, not ML
Think of QWED-MCP as giving Claude a "calculator" for math and a "theorem prover" for logic.
Claude reasons. QWED-MCP verifies.
🆚 How We're Different from Other MCP Servers
Aspect | Other MCP Servers | QWED-MCP |
Purpose | Connect to APIs, databases, files | Verify LLM outputs |
Approach | Fetch external data | Compute deterministic proofs |
Engines | API wrappers | SymPy, Z3, AST analyzers |
Accuracy | Depends on data source | 100% mathematically proven |
Offline | Often need internet | Fully local, no APIs |
With Claude Desktop
┌───────────────────┐ ┌───────────────────────┐ ┌───────────────────┐
│ Claude │ │ QWED-MCP │ │ Verified Answer │
│ "What's d/dx x³?" │ ──► │ execute_python_code() │ ──► │ "3x²" ✓ │
│ "Write script to │ │ Runs SymPy natively │ │ (STDOUT Captured) │
│ check." │ └───────────────────────┘ └───────────────────┘
└───────────────────┘🔒 Security & Privacy
All verification happens locally. Nothing is sent to external servers.
Concern | QWED-MCP Approach |
Data Transmission | ❌ No external API calls |
Storage | ❌ Nothing logged or stored |
Dependencies | ✅ Local engines (SymPy, Z3) |
Code Analysis | ✅ Your code never leaves your machine |
Perfect for:
Enterprises with strict security policies
Air-gapped development environments
Sensitive code review workflows
❓ FAQ
Yes! Open source under Apache 2.0. Use it commercially, modify it, distribute it.
QWED-MCP works with any MCP-compatible client. VS Code with Claude extension supports MCP, so yes!
No. QWED-MCP runs entirely locally. No API keys, no cloud calls.
QWED-Core is the Python library. QWED-MCP wraps it as an MCP server so Claude can use it as a tool.
Yes! The server is extensible. Fork it and add your custom @mcp.tool() functions.
🗺️ Roadmap
✅ Released (v0.3.0)
execute_python_codeadmits code by allowlist instead of a denylist: only listed modules, builtins and attributes (see What code is admitted)Only UTF-8 source encodings are admitted, and admitted code runs in isolated mode (
python -I). Fixes GHSA-425c-p25c-qxwh and GHSA-qj7c-h9rh-qppcMath engine refuses unknown operations, and expressions whose evaluation would exceed a size bound, before SymPy evaluates them
Logic engine reports
PROVEN,DISPROVENorUNVERIFIABLE; a statement it cannot read isUNVERIFIABLESQL engine parses the query with sqlglot instead of matching patterns, and the code engine's
sqlbranch gives the same verdictSkill provenance: registries are allowlisted by default, and a digest is checked against the skill's content when the content is supplied. A manifest-only check, such as the server's startup check, does not prove that the content matches the digest (
digest_verifiedis false)Dependencies: declares
anyioandsqlglot; no longer installsqwed-financeorqwed-ucp; no longer declareshttpxdirectly (mcpstill installs it)Release pipeline: actions pinned by SHA, publishing gated on CI and image scans, Docker image with Ubuntu security updates and pinned build inputs
Upgrading from 0.2.x
Code that 0.2.x ran may now be refused: anything that imports a module outside the allowlist (
os,pathlib,requests, QWED SDK packages and other third-party packages), callsopen,eval,getattror another refused builtin, or reads a private or special attribute. The refusal lists the reason.qwed-financeandqwed-ucpare no longer installed with qwed-mcp. Install them yourself if your own code imports them.httpxis no longer a direct dependency;mcpstill installs it, but declare it in your own project if your code imports it.Library users: logic results carry
verification_mode, and the math, logic and SQL engines report input they cannot decide as refused orUNVERIFIABLEinstead of returning a verdict for it.
✅ Released (v0.2.3)
Context bloat resolution (RFC-9728 compatibility)
Unified
execute_python_codeenvironmentSecure process isolation (env-restricted) and robust timeouts
Claude Desktop integration
Windows/macOS/Linux support
Hardened math sandbox: AST allowlist for expression evaluation (GHSA-2p69-jpm6-jrxh)
qwedai.comremoved from the trusted skill source domains (#71)Requires
mcp>=1.30.0,<2. MCP SDK 1.30.0 patches GHSA-84m7-p3x7-pcfv, GHSA-rwrf-2pqf-9j8j and GHSA-5h93-6whr-6q8j; for GHSA-w4fh-qvv9-3v23, HTTP servers that use the SDK's bearer authentication must also setvalidate_token_resource=True. qwed-mcp runs over stdio and uses neither the HTTP transports nor bearer authentication. MCP SDK 2.x removed the server API qwed-mcp usesReports its own version to MCP clients during initialisation
🚧 In Progress
verify_json— JSON Schema validation toolverify_finance— NPV/IRR/amortization toolCursor IDE integration guide
🔮 Planned
verify_legal— Deadline and liability verificationverify_statistics— Hypothesis test validationSSE (Server-Sent Events) transport for web UIs
TypeScript implementation
📁 Examples
See the examples/ folder for:
Python client usage
Sample verification scripts
Integration examples
🛠️ Development
# Clone
git clone https://github.com/QWED-AI/qwed-mcp.git
cd qwed-mcp
# Install with dev dependencies
pip install -e ".[dev]"
# Run tests
pytest tests/ -v
# Format code
black src/📖 Documentation
Resource | Link |
Full Docs | |
Tools Reference | |
Examples | |
Troubleshooting | |
MCP Protocol |
🔗 Related Projects
QWED Core — github.com/QWED-AI/qwed-verification
QWED-UCP — github.com/QWED-AI/qwed-ucp
QWED Open Responses — github.com/QWED-AI/qwed-open-responses
📄 License
Apache 2.0 — See LICENSE
Redistributions keep the attribution in NOTICE, and TRADEMARKS.md says how the QWED name and logo may be used.
Available Tools
2 toolsexecute_python_codeA
Executes Python code in a subprocess with restricted environment variables. Code runs only if every module, builtin and attribute it uses is on QWED's allowlist (computation-only standard-library modules such as math, decimal, fractions, statistics, itertools, json and re); anything else is refused before it runs. Admission is a static check, not a proof that the code is correct. The code runs with server privileges, and its output comes from the executed code, so treat it as untrusted data.
Inputs: code (required), background.
verification_statusB
Check the execution status and output of a background verification task.
Inputs: job_id (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 2 tools
The two tools are mostly distinct: one executes Python code and the other reports the status/output of a background verification task. There is minor ambiguity because the relationship between execution and background verification is not fully explained, but an agent can still tell the tools apart.
Both names use snake_case, which is consistent at the casing level. However, execute_python_code follows a verb_noun pattern while verification_status is noun_noun, so the naming convention is mixed but still readable.
Two tools is quite thin for a code-execution/verification server. The surface is focused, but it sits at the borderline where the set feels under-scoped rather than comfortably minimal.
The core pair covers executing code and checking background verification status/output. Notable gaps remain, such as creating or listing background tasks, cancelling execution, or discovering the allowlist, which may cause dead ends in some workflows.
Maintenance
Related MCP Connectors
Deterministic reasoning stack for AI agents: simulate, decide & compute, plus cross-domain tools.
Proves AI-generated Python does what you asked: lint, types, security, sandbox run, exact fixes.
Paid deterministic data-quality and execution-verification tools for AI agents.
Jailbreak-proof AI guardrails. Automated Reasoning SMT solver, not an LLM. ZK proofs included.
Related MCP Servers
- AlicenseAqualityBmaintenanceDeterministic AI safety policy engine with Z3 formal verification. Write, verify, simulate, and enforce machine-verifiable safety constraints for AI agents. Completely outside the LLM.1166 PyPI27Apache 2.0
- AlicenseAqualityDmaintenanceA secure mathematical computation sandbox that enables LLMs to perform symbolic math operations like algebra, calculus, and equation solving via SymPy. It features low-latency execution through pre-warmed process pools and provides standardized JSON outputs for reliable agent integration.119 PyPI2MIT
- FlicenseNot gradedqualityCmaintenanceEnables safe execution of Python code with AI assistance and integration with Model Context Protocol tools.1-
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to execute arbitrary Python code securely in a sandboxed environment with resource limits and security constraints via MCP protocol.MIT