vdb-mcp 0.1.0__tar.gz

vdb_mcp-0.1.0/.gitignore

@@ -0,0 +1,244 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+# Python venv dirs — anchored to repo root so they don't collide with
+# unrelated `lib/` directories elsewhere (e.g. docker/web/src/lib/).
+/lib/
+/lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# ── VDB project ─────────────────────────────────────────────────────────────
+.env
+.env.local
+.env.*.local
+backups/
+*.dump
+*.sql.gz
+
+# Docker
+docker/app/__pycache__/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+.DS_Store
+
+# ── VDB web (Astro) ─────────────────────────────────────────────────────────
+docker/web/node_modules/
+docker/web/dist/
+docker/web/.astro/
+docker/web/package-lock.json
+*.bak

vdb_mcp-0.1.0/Dockerfile

@@ -0,0 +1,33 @@
+# ─────────────────────────────────────────────────────────────────────────────
+#  vdb-mcp — MCP server that wraps the VDB REST API.
+#
+#  Usage (stdio mode, for Claude Desktop / Cursor):
+#      docker run -i --rm \
+#          -e VDB_API_URL=http://host.docker.internal:8080 \
+#          vdb/mcp:dev
+#
+#  Usage (HTTP/SSE mode, for remote clients):
+#      docker run -d -p 7700:7700 -e MCP_MODE=sse vdb/mcp:dev
+# ─────────────────────────────────────────────────────────────────────────────
+
+FROM python:3.12-slim
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        ca-certificates tini \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+RUN pip install --no-cache-dir "mcp>=1.0.0" "httpx>=0.27.0"
+
+COPY vdb_mcp /app/vdb_mcp
+
+ENV VDB_API_URL=http://api:8080 \
+    MCP_MODE=stdio \
+    MCP_PORT=7700
+
+ENTRYPOINT ["/usr/bin/tini", "--"]
+CMD ["python", "-m", "vdb_mcp.server"]

vdb_mcp-0.1.0/LICENSE

@@ -0,0 +1,99 @@
+Licensor: VDB (https://vdb.ai.kr) — Licensed Work: vdb-mcp
+You may use this software freely, including inside a commercial
+organization. You may NOT provide it to third parties as a hosted or
+managed service, or resell it as a product (see Limitations below).
+Commercial licensing inquiries: dev@egdee.com
+
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

vdb_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: vdb-mcp
+Version: 0.1.0
+Summary: MCP server for VDB — AI-aware vulnerability database (packages, MCP servers, models). Check packages for CVEs and slopsquatting before installing.
+Project-URL: Homepage, https://vdb.ai.kr
+Project-URL: Documentation, https://vdb.ai.kr/connect
+Project-URL: Repository, https://github.com/0pstech/vdb
+Author-email: VDB <dev@egdee.com>
+License: Elastic-2.0
+License-File: LICENSE
+Keywords: cve,mcp,model-context-protocol,osv,sbom,security,slopsquatting,supply-chain,vulnerability
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=1.0.0
+Description-Content-Type: text/markdown
+
+# vdb-mcp
+
+MCP (Model Context Protocol) server for **[VDB](https://vdb.ai.kr)** — the
+AI-aware vulnerability database. Lets Claude Desktop, Claude Code, Cursor,
+Cline, Continue, and any MCP client check packages **while generating code**:
+known CVEs, slopsquatting (LLM-hallucinated package names an attacker may have
+registered), CISA KEV status, MCP-server trust profiles, and more.
+
+## Quick start
+
+```bash
+uvx vdb-mcp          # or: pipx run vdb-mcp
+```
+
+Claude Desktop (`claude_desktop_config.json`) / Cursor (`.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "vdb": { "command": "uvx", "args": ["vdb-mcp"] }
+  }
+}
+```
+
+That's it — the server talks to the hosted instance at `https://vdb.ai.kr`
+by default. Anonymous use gets a free per-IP trial; add an API key for
+unmetered access (free at <https://vdb.ai.kr/signup>):
+
+```json
+{
+  "mcpServers": {
+    "vdb": {
+      "command": "uvx",
+      "args": ["vdb-mcp"],
+      "env": { "VDB_API_TOKEN": "vdb_..." }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `vdb_check_package` | Check one package (purl + optional version) for vulnerabilities, slop risk, KEV |
+| `vdb_check_packages` | Bulk slopsquatting / risk check for a list of packages |
+| `vdb_lookup` | Fetch one advisory by ID (CVE-…, GHSA-…, VDB-SLOP-…) |
+| `vdb_search` | Free-text search over the vulnerability corpus |
+| `vdb_check_mcp_server` | Trust tier + permission scopes of a community MCP server |
+| `vdb_list_slopsquatting` | Current slopsquatting candidates per ecosystem |
+
+## Environment
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `VDB_API_URL` | `https://vdb.ai.kr` | VDB instance to query (set for self-hosted) |
+| `VDB_API_TOKEN` | *(empty)* | `vdb_…` API key — unmetered, per-account quota |
+| `MCP_MODE` | `stdio` | `stdio` or `sse` (long-running HTTP server) |
+| `MCP_PORT` | `7700` | SSE port |
+
+## Why
+
+LLMs hallucinate package names; attackers register them (slopsquatting).
+LLMs also happily recommend packages with known RCEs. VDB gives your agent a
+guardrail: one tool call before `npm install` / `pip install`. See
+<https://vdb.ai.kr/connect> for the one-line prompt variant that needs no MCP
+at all.
+
+## License
+
+[Elastic License 2.0](https://www.elastic.co/licensing/elastic-license) —
+free to use, including inside commercial organizations and CI. The only
+restrictions: you may not offer this software to third parties as a hosted
+or managed service, or resell it as a product. Commercial licensing beyond
+that: <dev@egdee.com>. API usage is governed by the VDB service terms
+regardless of how you call it.

vdb_mcp-0.1.0/README.md

@@ -0,0 +1,76 @@
+# vdb-mcp
+
+MCP (Model Context Protocol) server for **[VDB](https://vdb.ai.kr)** — the
+AI-aware vulnerability database. Lets Claude Desktop, Claude Code, Cursor,
+Cline, Continue, and any MCP client check packages **while generating code**:
+known CVEs, slopsquatting (LLM-hallucinated package names an attacker may have
+registered), CISA KEV status, MCP-server trust profiles, and more.
+
+## Quick start
+
+```bash
+uvx vdb-mcp          # or: pipx run vdb-mcp
+```
+
+Claude Desktop (`claude_desktop_config.json`) / Cursor (`.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "vdb": { "command": "uvx", "args": ["vdb-mcp"] }
+  }
+}
+```
+
+That's it — the server talks to the hosted instance at `https://vdb.ai.kr`
+by default. Anonymous use gets a free per-IP trial; add an API key for
+unmetered access (free at <https://vdb.ai.kr/signup>):
+
+```json
+{
+  "mcpServers": {
+    "vdb": {
+      "command": "uvx",
+      "args": ["vdb-mcp"],
+      "env": { "VDB_API_TOKEN": "vdb_..." }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `vdb_check_package` | Check one package (purl + optional version) for vulnerabilities, slop risk, KEV |
+| `vdb_check_packages` | Bulk slopsquatting / risk check for a list of packages |
+| `vdb_lookup` | Fetch one advisory by ID (CVE-…, GHSA-…, VDB-SLOP-…) |
+| `vdb_search` | Free-text search over the vulnerability corpus |
+| `vdb_check_mcp_server` | Trust tier + permission scopes of a community MCP server |
+| `vdb_list_slopsquatting` | Current slopsquatting candidates per ecosystem |
+
+## Environment
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `VDB_API_URL` | `https://vdb.ai.kr` | VDB instance to query (set for self-hosted) |
+| `VDB_API_TOKEN` | *(empty)* | `vdb_…` API key — unmetered, per-account quota |
+| `MCP_MODE` | `stdio` | `stdio` or `sse` (long-running HTTP server) |
+| `MCP_PORT` | `7700` | SSE port |
+
+## Why
+
+LLMs hallucinate package names; attackers register them (slopsquatting).
+LLMs also happily recommend packages with known RCEs. VDB gives your agent a
+guardrail: one tool call before `npm install` / `pip install`. See
+<https://vdb.ai.kr/connect> for the one-line prompt variant that needs no MCP
+at all.
+
+## License
+
+[Elastic License 2.0](https://www.elastic.co/licensing/elastic-license) —
+free to use, including inside commercial organizations and CI. The only
+restrictions: you may not offer this software to third parties as a hosted
+or managed service, or resell it as a product. Commercial licensing beyond
+that: <dev@egdee.com>. API usage is governed by the VDB service terms
+regardless of how you call it.

vdb_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vdb-mcp"
+version = "0.1.0"
+description = "MCP server for VDB — AI-aware vulnerability database (packages, MCP servers, models). Check packages for CVEs and slopsquatting before installing."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Elastic-2.0" }
+authors = [{ name = "VDB", email = "dev@egdee.com" }]
+keywords = [
+    "mcp", "model-context-protocol", "security", "vulnerability",
+    "sbom", "slopsquatting", "supply-chain", "cve", "osv",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: Other/Proprietary License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Security",
+]
+dependencies = [
+    # `mcp` pulls starlette/uvicorn needed by the optional SSE mode.
+    "mcp>=1.0.0",
+    "httpx>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://vdb.ai.kr"
+Documentation = "https://vdb.ai.kr/connect"
+Repository = "https://github.com/0pstech/vdb"
+
+[project.scripts]
+vdb-mcp = "vdb_mcp.server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["vdb_mcp"]

vdb_mcp-0.1.0/server.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-09-29/server.schema.json",
+  "name": "kr.ai.vdb/vdb",
+  "description": "AI-aware vulnerability database: check packages for CVEs, slopsquatting, and KEV status; audit MCP servers and SBOMs — before your agent installs anything.",
+  "repository": {
+    "url": "https://github.com/0pstech/vdb",
+    "source": "github"
+  },
+  "version": "0.1.0",
+  "websiteUrl": "https://vdb.ai.kr",
+  "packages": [
+    {
+      "registryType": "pypi",
+      "registryBaseUrl": "https://pypi.org",
+      "identifier": "vdb-mcp",
+      "version": "0.1.0",
+      "transport": { "type": "stdio" },
+      "environmentVariables": [
+        {
+          "name": "VDB_API_URL",
+          "description": "VDB instance origin. Defaults to the hosted https://vdb.ai.kr.",
+          "isRequired": false,
+          "isSecret": false
+        },
+        {
+          "name": "VDB_API_TOKEN",
+          "description": "Optional vdb_… API key for unmetered per-account access (free at https://vdb.ai.kr/signup). Anonymous use gets a per-IP trial.",
+          "isRequired": false,
+          "isSecret": true
+        }
+      ]
+    }
+  ]
+}

vdb_mcp-0.1.0/smithery.yaml

@@ -0,0 +1,30 @@
+# Smithery.ai registry config for the VDB MCP server.
+# Docs: https://smithery.ai/docs — validate against their current schema
+# before submitting; this file targets the container runtime.
+startCommand:
+  type: stdio
+  configSchema:
+    type: object
+    properties:
+      vdbApiUrl:
+        type: string
+        title: VDB instance URL
+        description: Origin of the VDB instance to query. Leave default for the hosted service.
+        default: https://vdb.ai.kr
+      vdbApiToken:
+        type: string
+        title: VDB API key (optional)
+        description: vdb_… key for unmetered per-account access. Free at https://vdb.ai.kr/signup. Anonymous use gets a per-IP trial.
+  commandFunction: |-
+    (config) => ({
+      command: "python",
+      args: ["-m", "vdb_mcp.server"],
+      env: {
+        VDB_API_URL: config.vdbApiUrl || "https://vdb.ai.kr",
+        ...(config.vdbApiToken ? { VDB_API_TOKEN: config.vdbApiToken } : {}),
+        MCP_MODE: "stdio"
+      }
+    })
+build:
+  dockerfile: Dockerfile
+  dockerBuildPath: .

vdb_mcp-0.1.0/vdb_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""vdb-mcp — MCP server wrapping the VDB vulnerability database API."""
+
+__version__ = "0.1.0"

vdb_mcp-0.1.0/vdb_mcp/server.py

@@ -0,0 +1,302 @@
+"""VDB MCP server.
+
+Wraps the VDB REST API in the Model Context Protocol so any MCP-aware client
+(Claude Desktop, Cursor, Cline, Continue, …) can call it during code generation
+to check packages, scan SBOMs, and look up vulnerabilities.
+
+Modes:
+    stdio  (default)  spawned by the client as a subprocess. JSON-RPC on stdio.
+    sse                long-running HTTP server on $MCP_PORT.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+from typing import Any
+
+import httpx
+from mcp.server import NotificationOptions, Server
+from mcp.server.models import InitializationOptions
+from mcp.types import TextContent, Tool
+
+from . import __version__
+
+log = logging.getLogger("vdb.mcp")
+logging.basicConfig(level=os.environ.get("VDB_LOG_LEVEL", "INFO"))
+
+# Default to the public hosted instance so `uvx vdb-mcp` works with zero
+# config. The docker-compose deployment overrides this with the in-cluster
+# URL (http://api:8080); self-hosters set VDB_API_URL to their own origin.
+API_URL = os.environ.get("VDB_API_URL", "https://vdb.ai.kr").rstrip("/")
+API_TOKEN = os.environ.get("VDB_API_TOKEN", "")
+
+server = Server("vdb")
+
+
+def _headers() -> dict[str, str]:
+    h = {"Accept": "application/json"}
+    if API_TOKEN:
+        h["Authorization"] = f"Bearer {API_TOKEN}"
+    return h
+
+
+async def _get(path: str, params: dict | None = None) -> Any:
+    async with httpx.AsyncClient(timeout=15) as c:
+        r = await c.get(f"{API_URL}{path}", params=params, headers=_headers())
+        r.raise_for_status()
+        return r.json()
+
+
+async def _post(path: str, body: dict) -> Any:
+    async with httpx.AsyncClient(timeout=30) as c:
+        r = await c.post(
+            f"{API_URL}{path}",
+            json=body,
+            headers={**_headers(), "Content-Type": "application/json"},
+        )
+        r.raise_for_status()
+        return r.json()
+
+
+# ── Tool list ────────────────────────────────────────────────────────────────
+
+@server.list_tools()
+async def list_tools() -> list[Tool]:
+    return [
+        Tool(
+            name="vdb_check_package",
+            description=(
+                "BEFORE recommending or installing any package, call this to check the package "
+                "against the VDB vulnerability and slopsquatting database. Returns known "
+                "vulnerabilities, slop risk, KEV status, and severity buckets."
+            ),
+            inputSchema={
+                "type": "object",
+                "required": ["purl"],
+                "properties": {
+                    "purl": {
+                        "type": "string",
+                        "description": "Package URL, e.g. 'pkg:npm/lodash' or 'pkg:pypi/requests'",
+                    },
+                    "version": {
+                        "type": "string",
+                        "description": "Optional version. If supplied, range matching is applied.",
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="vdb_check_packages",
+            description=(
+                "Bulk-check multiple package names for slopsquatting risk. Use this when an "
+                "LLM-generated response references multiple packages — it's faster than calling "
+                "vdb_check_package per item."
+            ),
+            inputSchema={
+                "type": "object",
+                "required": ["packages"],
+                "properties": {
+                    "packages": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "List of PURLs or 'ecosystem/name' shorthand.",
+                    }
+                },
+            },
+        ),
+        Tool(
+            name="vdb_lookup",
+            description="Fetch a single vulnerability by ID or alias (e.g. CVE-2024-1234, GHSA-xxxx-yyyy-zzzz, VDB-SLOP-…).",
+            inputSchema={
+                "type": "object",
+                "required": ["id"],
+                "properties": {"id": {"type": "string"}},
+            },
+        ),
+        Tool(
+            name="vdb_search",
+            description="Free-text search over the VDB vulnerability corpus.",
+            inputSchema={
+                "type": "object",
+                "required": ["query"],
+                "properties": {
+                    "query": {"type": "string"},
+                    "limit": {"type": "integer", "default": 20},
+                },
+            },
+        ),
+        Tool(
+            name="vdb_check_mcp_server",
+            description=(
+                "BEFORE recommending the user install a community/unofficial MCP server, "
+                "call this to look up its declared scopes, trust tier, and known risk profile."
+            ),
+            inputSchema={
+                "type": "object",
+                "required": ["server_id"],
+                "properties": {"server_id": {"type": "string", "description": "e.g. 'mcp:community/shell-runner'"}},
+            },
+        ),
+        Tool(
+            name="vdb_list_slopsquatting",
+            description="List packages currently flagged as slopsquatting candidates in a given ecosystem.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "ecosystem": {"type": "string", "description": "npm | PyPI | crates.io | Go | Maven"},
+                    "limit":     {"type": "integer", "default": 50},
+                },
+            },
+        ),
+    ]
+
+
+# ── Tool dispatch ───────────────────────────────────────────────────────────
+
+async def _tool_check_package(args: dict) -> list[TextContent]:
+    purl = args["purl"]
+    version = args.get("version")
+    data = await _post("/v1/query", {"package": {"purl": purl}, "version": version})
+    vulns = data.get("vulns") or []
+    summary = {
+        "purl": purl,
+        "version": version,
+        "vulnerabilities_found": len(vulns),
+        "top": [
+            {
+                "id": v.get("id"),
+                "summary": v.get("summary"),
+                "severity": (v.get("database_specific") or {}).get("severity"),
+                "slop_risk": ((v.get("vdb_signals") or {}).get("ai_context") or {})
+                              .get("slopsquatting", {}).get("risk"),
+            }
+            for v in vulns[:10]
+        ],
+    }
+    return [TextContent(type="text", text=json.dumps(summary, indent=2, ensure_ascii=False))]
+
+
+async def _tool_check_packages(args: dict) -> list[TextContent]:
+    pkgs = args["packages"]
+    data = await _post("/v1/ai/check-packages", {"packages": pkgs})
+    return [TextContent(type="text", text=json.dumps(data, indent=2, ensure_ascii=False))]
+
+
+async def _tool_lookup(args: dict) -> list[TextContent]:
+    data = await _get(f"/v1/vulns/{args['id']}")
+    return [TextContent(type="text", text=json.dumps(data, indent=2, ensure_ascii=False))]
+
+
+async def _tool_search(args: dict) -> list[TextContent]:
+    data = await _get("/v1/search", {"q": args["query"], "limit": args.get("limit", 20)})
+    items = [
+        {
+            "id": v.get("id"),
+            "summary": v.get("summary"),
+            "severity": (v.get("database_specific") or {}).get("severity"),
+        }
+        for v in (data.get("vulns") or [])
+    ]
+    return [TextContent(type="text", text=json.dumps({"query": args["query"], "items": items},
+                                                     indent=2, ensure_ascii=False))]
+
+
+async def _tool_check_mcp_server(args: dict) -> list[TextContent]:
+    data = await _get(f"/v1/ai/mcp-servers/{args['server_id']}")
+    return [TextContent(type="text", text=json.dumps(data, indent=2, ensure_ascii=False))]
+
+
+async def _tool_list_slop(args: dict) -> list[TextContent]:
+    params = {"limit": args.get("limit", 50)}
+    if args.get("ecosystem"):
+        params["ecosystem"] = args["ecosystem"]
+    data = await _get("/v1/ai/slopsquatting", params)
+    return [TextContent(type="text", text=json.dumps(data, indent=2, ensure_ascii=False))]
+
+
+_DISPATCH = {
+    "vdb_check_package":      _tool_check_package,
+    "vdb_check_packages":     _tool_check_packages,
+    "vdb_lookup":             _tool_lookup,
+    "vdb_search":             _tool_search,
+    "vdb_check_mcp_server":   _tool_check_mcp_server,
+    "vdb_list_slopsquatting": _tool_list_slop,
+}
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+    fn = _DISPATCH.get(name)
+    if not fn:
+        return [TextContent(type="text", text=f"unknown tool: {name}")]
+    try:
+        return await fn(arguments)
+    except httpx.HTTPStatusError as e:
+        return [TextContent(type="text", text=f"VDB API error {e.response.status_code}: {e.response.text[:300]}")]
+    except Exception as e:  # noqa: BLE001
+        return [TextContent(type="text", text=f"error: {e}")]
+
+
+# ── Entry point ─────────────────────────────────────────────────────────────
+
+async def main_stdio() -> None:
+    from mcp.server.stdio import stdio_server
+    async with stdio_server() as (read, write):
+        await server.run(
+            read, write,
+            InitializationOptions(
+                server_name="vdb",
+                server_version=__version__,
+                capabilities=server.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                ),
+            ),
+        )
+
+
+async def main_sse() -> None:
+    """Long-running HTTP/SSE mode on $MCP_PORT (default 7700)."""
+    from mcp.server.sse import SseServerTransport
+    from starlette.applications import Starlette
+    from starlette.routing import Route, Mount
+    import uvicorn
+
+    port = int(os.environ.get("MCP_PORT", "7700"))
+    sse = SseServerTransport("/messages/")
+
+    async def handle_sse(request):
+        async with sse.connect_sse(request.scope, request.receive, request._send) as (r, w):
+            await server.run(
+                r, w,
+                InitializationOptions(
+                    server_name="vdb", server_version=__version__,
+                    capabilities=server.get_capabilities(
+                        notification_options=NotificationOptions(),
+                        experimental_capabilities={},
+                    ),
+                ),
+            )
+
+    app = Starlette(routes=[
+        Route("/sse", endpoint=handle_sse),
+        Mount("/messages/", app=sse.handle_post_message),
+    ])
+    log.info("vdb-mcp serving SSE at 0.0.0.0:%d /sse", port)
+    config = uvicorn.Config(app, host="0.0.0.0", port=port, log_level="info")
+    await uvicorn.Server(config).serve()
+
+
+def main() -> None:
+    mode = os.environ.get("MCP_MODE", "stdio")
+    if mode == "sse":
+        asyncio.run(main_sse())
+    else:
+        asyncio.run(main_stdio())
+
+
+if __name__ == "__main__":
+    main()