nexatron-mcp 1.0.0__tar.gz

nexatron_mcp-1.0.0/.gitignore

@@ -0,0 +1,27 @@
+# Build artifacts
+dist/
+build/
+*.egg-info/
+*.egg
+
+# Test / coverage artifacts
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+coverage.xml
+.coverage
+htmlcov/
+
+# Virtual environments (local development)
+.venv/
+.test-venv/
+venv/
+
+# Python bytecode
+__pycache__/
+*.py[cod]
+*$py.class
+
+# OS
+.DS_Store
+Thumbs.db

nexatron_mcp-1.0.0/CHANGELOG.md

@@ -0,0 +1,59 @@
+# Changelog
+
+All notable changes to `nexatron-mcp` are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Fixed
+- `pyproject.toml` version was incorrectly set to `2.0.0` with a description advertising an aspirational `ask` / `query_metric` / `compare_metric_across_sources` / `explain_metric` tool surface that was never shipped. Reset to `1.0.0` to match the actual 12-tool surface documented in this changelog and in `README.md`. No code or behavior change for installed users.
+
+## [1.0.0] — 2026-04-17
+
+**Production release** — the `nexatron-mcp` package is now a production-grade, enterprise-supported MCP server from **dotSolved Systems**, backed by SOC 2 Type 1 and ISO 27001 corporate compliance (Type 2 in progress).
+
+### Added
+- **12 MCP tools** exposed to Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, and any other MCP-compatible AI client:
+  - `query` — ask questions about enterprise data in plain English; returns answer, generated SQL, result preview, and confidence score.
+  - `list_connections` — list all configured data source connections (Postgres, MySQL, SQL Server, BigQuery, Snowflake, Redshift, Databricks, Salesforce, S3).
+  - `get_schema` — fetch the schema for a specific connection (tables, columns, types).
+  - `test_connection` — verify connectivity and credentials.
+  - `detect_schema_drift` — report schema changes (added / removed / type-changed columns).
+  - `list_metrics` — list all metrics in the Nexatron semantic layer with certification status.
+  - `list_views` — list logical views defined in the semantic layer.
+  - `search_knowledge_base` — semantic search over ingested PDFs, docs, and unstructured sources (RAG).
+  - `list_conversations` — list recent query conversations for the authenticated user.
+  - `get_report` — retrieve a saved report by ID.
+  - `get_credit_balance` — check remaining query credits for the tenant.
+  - `whoami` — return the authenticated user and tenant context.
+- **1 MCP resource**: `nexatron://platform/info` — live platform overview and capabilities manifest.
+- **Two transport modes**:
+  - `stdio` (default) — for local AI clients (Claude Desktop, Cursor, VS Code, Windsurf).
+  - `sse` — Server-Sent Events for remote / cloud AI clients (including claude.ai custom integrations when used with the Nexatron backend's remote MCP endpoint).
+- **Authentication**: Nexatron API keys (`nxa_*` prefix), stored SHA-256 hashed on the backend. Per-key scopes, expiration, IP allowlist, and revocation via `POST /api/v1/admin/api-keys`.
+- **Tenant isolation**: every tool call is enforced through Nexatron's frozen `TenantContext` + four-layer row-level security, so an API key never sees another tenant's data.
+- **BYO-LLM**: inherits the Nexatron tenant's Smart LLM Router configuration — queries route through the customer's Azure OpenAI, Bedrock, Anthropic, or Ollama contract with no vendor lock-in at the MCP layer.
+- **Cryptographic audit trail**: every tool call is recorded in the Nexatron per-tenant audit log with HKDF-SHA256 export signing.
+
+### Quality
+- Full PEP 561 typing support (`py.typed` marker distributed in the wheel).
+- Strict `mypy` type-check clean.
+- `ruff` lint clean with security rules enabled (flake8-bandit).
+- `pytest` suite with ≥70% coverage gate.
+- GitHub Actions CI: test on every PR, auto-publish to PyPI on signed tag.
+
+### Security
+- See [SECURITY.md](SECURITY.md) for the responsible disclosure policy.
+- No secrets ever logged; API key only transits the `Authorization: Bearer` header.
+- Explicit `httpx` timeout defaults; no unbounded network calls.
+
+### Compatibility
+- Requires Python ≥ 3.10.
+- Tested on Python 3.10, 3.11, 3.12, 3.13 in CI.
+- Tested against Nexatron API ≥ v1.0.0.
+- Compatible with every MCP client implementing the 2024-11 protocol spec (at minimum: Claude Desktop, Claude Code, Cursor, VS Code MCP, Windsurf).
+
+## [0.1.0] — 2026-02 (internal beta)
+
+Initial beta release to dotSolved design-partner customers. Not published to PyPI.

nexatron_mcp-1.0.0/CONTRIBUTING.md

@@ -0,0 +1,136 @@
+# Contributing to nexatron-mcp
+
+Thanks for your interest in contributing to the Nexatron MCP server. This package is maintained by **dotSolved Systems** as part of the Nexatron platform; contributions from the community are welcome and reviewed by the Nexatron engineering team.
+
+## Ground rules
+
+1. **Open an issue first** for anything larger than a one-line fix. This lets us discuss design before you invest time.
+2. **Every change must be tested.** Pull requests without tests will be asked to add them.
+3. **Every change must pass CI.** `ruff`, `mypy --strict`, and `pytest` all must be green. The CI gate is automatic on every PR.
+4. **Do not break the public API.** The tools exposed to MCP clients (`query`, `list_connections`, etc.) are part of the public contract; changing their name, parameters, or response shape is a breaking change and requires a major version bump.
+5. **Security-sensitive changes** (authentication, request signing, secrets handling) require a two-person review — one Nexatron engineer and one dotSolved security reviewer.
+
+## Development setup
+
+```bash
+# From the repo root
+cd packages/mcp-server
+
+# Create and activate a virtual environment
+python -m venv .venv
+source .venv/bin/activate    # on Windows: .venv\Scripts\activate
+
+# Install the package in editable mode with dev extras
+pip install -e ".[dev]"
+
+# Verify the install
+nexatron-mcp --help
+```
+
+## Running the tests
+
+```bash
+# Fast unit tests
+pytest
+
+# Verbose with coverage summary
+pytest -v
+
+# With coverage HTML report
+pytest --cov-report=html && open htmlcov/index.html
+```
+
+The coverage gate is **70%**. Drops below that fail CI.
+
+## Linting and type checking
+
+```bash
+# Lint (auto-fix where possible)
+ruff check --fix .
+
+# Format
+ruff format .
+
+# Type check (strict)
+mypy src/nexatron_mcp
+```
+
+## Pull request checklist
+
+Before opening a PR, please ensure:
+
+- [ ] Tests pass locally (`pytest`).
+- [ ] Lint passes (`ruff check .`).
+- [ ] Type check passes (`mypy src/nexatron_mcp`).
+- [ ] You added or updated tests for the behavior you changed.
+- [ ] You updated [CHANGELOG.md](CHANGELOG.md) with your change under `[Unreleased]`.
+- [ ] You updated [README.md](README.md) if the public API or install instructions changed.
+- [ ] For tool additions: the new tool has a clear docstring, parameter types, and at least one example in the PR description.
+
+## Commit messages
+
+We use [Conventional Commits](https://www.conventionalcommits.org/):
+
+- `feat(tools): add list_tenants tool`
+- `fix(client): handle httpx timeout gracefully`
+- `docs(readme): clarify sse setup for claude.ai`
+- `test(server): cover credit_balance edge cases`
+- `chore(ci): upgrade actions/checkout to v5`
+
+## Release process
+
+Releases are cut by Nexatron engineering maintainers. The sequence:
+
+1. Update `version` in [pyproject.toml](pyproject.toml), `__version__` in `src/nexatron_mcp/__init__.py`, **and both `version` fields in [server.json](server.json)** (top-level + `packages[0].version`). The publish workflow refuses to ship unless all three agree with the tag.
+2. Move entries from `[Unreleased]` to a new dated section in [CHANGELOG.md](CHANGELOG.md).
+3. Open a PR titled `release: mcp-server-v<new-version>`; merge when approved and green.
+4. Tag the merge commit: `git tag mcp-server-vX.Y.Z && git push --tags`. The package-scoped prefix avoids overlap with Nexatron platform release tags.
+5. The [`mcp-publish`](../../.github/workflows/mcp-publish.yml) workflow picks up the tag, builds the wheel + sdist, publishes to PyPI via OIDC trusted publishing (no long-lived token), then publishes [`server.json`](server.json) to the MCP Registry at [`registry.modelcontextprotocol.io`](https://registry.modelcontextprotocol.io) using `mcp-publisher login github-oidc`.
+
+### First-publish runbook (one-time setup)
+
+The OIDC paths above need two one-time configurations before the first tag works end-to-end:
+
+**1. PyPI trusted publisher.** A PyPI account with maintainer permission on the `nexatron-mcp` project (or an admin who can create it) registers this repo as a trusted publisher at <https://pypi.org/manage/account/publishing/>:
+
+- Owner: `sravanmodugula-solved`
+- Repository: `nexatron`
+- Workflow filename: `mcp-publish.yml`
+- Environment: leave blank (the workflow does not use a deployment environment)
+
+No client secret is exchanged; PyPI verifies the OIDC `id-token` matches the configured repo + workflow at publish time. If the `nexatron-mcp` project does not yet exist on PyPI, the first publish creates it under the account that authorized the trusted publisher.
+
+**2. MCP Registry namespace ownership.** The namespace `io.github.sravanmodugula-solved/...` is verified by GitHub OIDC at publish time — there is no separate registration step. The verification logic checks that the OIDC `repository_owner` claim equals `sravanmodugula-solved`, so any tag pushed from a fork (different owner) will be rejected. To migrate to a custom domain namespace like `ai.dotsolved.nexatron/mcp`, set up a DNS TXT record per the [MCP Registry DNS auth docs](https://github.com/modelcontextprotocol/registry/blob/main/docs/modelcontextprotocol-io/authentication.mdx) and change the `login` step in `mcp-publish.yml` to `dns` auth.
+
+### Verifying a release end to end
+
+After the workflow finishes, confirm the release on both sides:
+
+```bash
+# PyPI
+pip index versions nexatron-mcp           # should show the new version
+uvx nexatron-mcp@<version> --help          # smoke-test the published artifact
+
+# MCP Registry
+curl -s "https://registry.modelcontextprotocol.io/v0/servers?search=nexatron" | jq .
+```
+
+The Cursor + Claude Desktop discovery surfaces consume the registry, so a successful registry publish is the discovery-flow handoff — there is no separate Cursor or Anthropic Console submission.
+
+### Dry run
+
+To validate the workflow without publishing:
+
+```bash
+gh workflow run mcp-publish.yml -f dry_run=true
+```
+
+The dry run still builds the sdist + wheel and installs `mcp-publisher`, so it catches packaging errors and the `mcp-publisher --help` smoke-test, without uploading anything.
+
+## Reporting security issues
+
+**Do not open a public issue for a security vulnerability.** See [SECURITY.md](SECURITY.md) for the coordinated disclosure process.
+
+## Licensing
+
+By contributing, you agree that your contributions will be licensed under the [MIT License](LICENSE) used by this project. dotSolved Systems retains copyright on all contributions.

nexatron_mcp-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dotSolved Systems, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nexatron_mcp-1.0.0/PKG-INFO

@@ -0,0 +1,409 @@
+Metadata-Version: 2.4
+Name: nexatron-mcp
+Version: 1.0.0
+Summary: Nexatron MCP server — governed enterprise-data access for Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, and any MCP-compatible AI client. Exposes 12 tools (query, list_connections, get_schema, list_metrics, list_views, search_knowledge_base, detect_schema_drift, test_connection, list_conversations, get_report, get_credit_balance, whoami) and 1 resource (nexatron://platform/info) over the Nexatron REST API with per-tenant isolation and cryptographic audit.
+Project-URL: Homepage, https://nexatron.io
+Project-URL: Documentation, https://docs.nexatron.io
+Project-URL: Repository, https://github.com/sravanmodugula-solved/nexatron
+Project-URL: Issues, https://github.com/sravanmodugula-solved/nexatron/issues
+Project-URL: Changelog, https://github.com/sravanmodugula-solved/nexatron/blob/main/packages/mcp-server/CHANGELOG.md
+Project-URL: Parent Company, https://dotsolved.com
+Author-email: "dotSolved Systems, Inc." <info@dotsolved.com>
+Maintainer-email: Nexatron Engineering <nexatron@dotsolved.com>
+License: MIT
+License-File: LICENSE
+Keywords: ai,analytics,bi,business-intelligence,claude,claude-code,claude-desktop,cursor,data,dotsolved,enterprise,mcp,model-context-protocol,natural-language,nexatron,nl-to-sql,semantic-layer,text-to-sql,voice
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Environment :: Plugins
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Database
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27.0
+Requires-Dist: mcp<2,>=1.0.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == 'dev'
+Requires-Dist: mypy>=1.11.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.30.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.6.0; extra == 'dev'
+Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'dev'
+Requires-Dist: twine>=5.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# nexatron-mcp
+
+<!-- mcp-name: io.github.sravanmodugula-solved/nexatron-mcp -->
+
+MCP server for the [Nexatron](https://nexatron.io) AI Data Intelligence Platform. Ask questions about your enterprise data directly from Claude.
+
+## Two ways to connect
+
+- **Hosted endpoint (recommended)** — `https://api.nexatron.io/api/v1/mcp` over OAuth 2.1. Nothing to install; exposes the full **governed v2 surface** (ten data-access tools incl. `ask`, `query_metric`, `compare_metric_across_sources`, plus the governance-contract tools and per-call lineage). MCP-aware clients (claude.ai, Claude Desktop, Cursor) discover it from the [registry](https://registry.modelcontextprotocol.io) entry. See [docs.nexatron.io/integrations/mcp-reference](https://docs.nexatron.io/integrations/mcp-reference).
+- **Local stdio package (this package)** — `uvx nexatron-mcp`, authenticated with an `nxa_` API key. A **REST-backed subset** for self-hosted Nexatron instances and offline-style local use; exposes the tools listed under [Available tools](#available-tools-local-stdio-package) below. The two surfaces are versioned independently.
+
+## Install
+
+```bash
+pip install nexatron-mcp
+# or
+uvx nexatron-mcp
+```
+
+## Setup
+
+### Claude Desktop
+
+Add to `~/.claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "nexatron": {
+      "command": "uvx",
+      "args": ["nexatron-mcp"],
+      "env": {
+        "NEXATRON_API_KEY": "nxa_your_api_key",
+        "NEXATRON_URL": "https://api.nexatron.io/api/v1"
+      }
+    }
+  }
+}
+```
+
+Restart Claude Desktop. You'll see Nexatron tools available.
+
+### Claude Code
+
+```bash
+claude mcp add nexatron -- uvx nexatron-mcp \
+  --env NEXATRON_API_KEY=nxa_your_key \
+  --env NEXATRON_URL=https://api.nexatron.io/api/v1
+```
+
+### Cursor / VS Code
+
+Add to `.cursor/mcp.json` or VS Code MCP settings:
+
+```json
+{
+  "mcpServers": {
+    "nexatron": {
+      "command": "uvx",
+      "args": ["nexatron-mcp"],
+      "env": {
+        "NEXATRON_API_KEY": "nxa_your_key",
+        "NEXATRON_URL": "https://api.nexatron.io/api/v1"
+      }
+    }
+  }
+}
+```
+
+## Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `NEXATRON_API_KEY` | Yes | — | Your Nexatron API key (starts with `nxa_`) |
+| `NEXATRON_URL` | No | `http://localhost:8000/api/v1` | Nexatron API URL |
+
+## Available tools (local stdio package)
+
+These are the tools the installable `nexatron-mcp` stdio package exposes against the Nexatron REST API. The hosted endpoint exposes the broader governed v2 surface described in [Two ways to connect](#two-ways-to-connect).
+
+| Tool | Description |
+|------|-------------|
+| `query` | Ask questions about your data in plain English |
+| `list_connections` | See all data source connections |
+| `list_metrics` | View certified metrics in the semantic layer |
+| `list_views` | View logical views |
+| `get_schema` | Explore database schemas |
+| `test_connection` | Test data source connectivity |
+| `detect_schema_drift` | Find schema changes |
+| `search_knowledge_base` | Search uploaded documents (RAG) |
+| `list_conversations` | View recent query history |
+| `get_report` | Retrieve a saved report |
+| `get_credit_balance` | Check remaining query credits |
+| `whoami` | Show your user info and organization |
+
+## Example
+
+After setup, ask Claude:
+
+> "Use Nexatron to show me total revenue by product category for Q4"
+
+Claude will call the `query` tool, which sends your question through Nexatron's AI pipeline and returns the answer with SQL and results.
+
+## SSE Transport (Remote)
+
+For remote or web-based MCP clients:
+
+```bash
+NEXATRON_API_KEY=nxa_... nexatron-mcp --sse --port 8001
+```
+
+## Development
+
+```bash
+git clone https://github.com/sravanmodugula-solved/nexatron
+cd nexatron/packages/mcp-server
+pip install -e .
+nexatron-mcp
+```
+
+## License
+
+MIT
+
+---
+
+# Release & registry submission runbook
+
+> Merged from the former `docs/integrations/mcp-server.md` (2026-06 necessity
+> audit) — this README is the natural home for "how to release this package."
+> Status tables below reflect pre-submission state; update as registries are
+> submitted.
+
+## 1. PyPI — publish `nexatron-mcp`
+
+The `nexatron-mcp` Python package is the primary artifact. It must be on PyPI before registry entries link to it, because installation commands reference `pip install nexatron-mcp` and `uvx nexatron-mcp`.
+
+### Pre-flight checklist
+
+- [ ] All tests pass: `cd packages/mcp-server && uv run --with pytest --with pytest-asyncio --with pytest-httpx --with pytest-cov python -m pytest`
+- [ ] Lint clean: `uv run --with ruff ruff check src/ tests/`
+- [ ] Version in `pyproject.toml` and `src/nexatron_mcp/__init__.py` match (currently `1.0.0`).
+- [ ] `CHANGELOG.md` has an entry for the version being published.
+- [ ] Build artifacts are clean: `rm -rf dist/ && uv run --with build python -m build`
+
+### Publish steps
+
+```bash
+cd packages/mcp-server
+
+# Build wheel and sdist
+uv run --with build python -m build
+
+# Check the dist before upload
+uv run --with twine twine check dist/*
+
+# Upload to PyPI (requires PyPI account with push rights to nexatron-mcp)
+uv run --with twine twine upload dist/*
+# You will be prompted for a PyPI API token (not a username/password).
+# Store the token in your password manager, not in any file committed to git.
+```
+
+Alternatively, the GitHub Actions workflow `.github/workflows/mcp-publish.yml` (tag-triggered on `mcp-server-v*`) runs this via PyPI trusted publishing (OIDC) without a stored token — preferred for CI — and then publishes `server.json` to the MCP Registry.
+
+After upload, verify at https://pypi.org/project/nexatron-mcp/.
+
+---
+
+## 2. Anthropic MCP Directory (open registry)
+
+The Anthropic open MCP directory is maintained as a GitHub repository at https://github.com/modelcontextprotocol/servers. Listing is via pull request.
+
+### What to prepare
+
+The directory uses a YAML entry per server. The proposed entry (ready to copy) is in `docs/integrations/anthropic-directory-submission.md` section 6. It looks like this:
+
+```yaml
+- name: nexatron
+  description: Ask questions about your enterprise data in plain English. AI analytics engine from dotSolved.
+  category: data-analytics
+  homepage: https://nexatron.io
+  source: https://github.com/sravanmodugula-solved/nexatron/tree/main/packages/mcp-server
+  package: nexatron-mcp
+  install: uvx nexatron-mcp
+  license: MIT
+  maintainer: dotSolved Systems, Inc.
+  maintainer_email: nexatron@dotsolved.com
+  supports_remote: true
+  remote_manifest: https://api.nexatron.io/.well-known/mcp/server.json
+  tags:
+    - data
+    - analytics
+    - bi
+    - nl-to-sql
+    - semantic-layer
+    - enterprise
+    - soc2
+```
+
+### Submission steps
+
+1. Fork https://github.com/modelcontextprotocol/servers.
+2. Add the YAML entry above to the appropriate category file (check the repo structure; it likely has a `servers/data-analytics/` directory or a top-level `servers.yaml`).
+3. Open a pull request with the title: `Add Nexatron MCP server (nexatron-mcp)`.
+4. Use the PR description template from `docs/integrations/anthropic-directory-submission.md` Appendix B.
+5. Assign the PR to a dotSolved engineer to monitor and respond to reviewer comments.
+
+### Notes
+
+- The `nexatron-mcp` package must be on PyPI before submitting, because reviewers will run `uvx nexatron-mcp` to verify.
+- The `.well-known/mcp/server.json` endpoint must be live and return a valid manifest. The static file is at `docs/integrations/nexatron-mcp-manifest.json`; the backend serves it from `app/api/wellknown.py` (verify that endpoint is deployed).
+- Estimated Anthropic review time: 1-7 business days based on past community submissions.
+
+---
+
+## 3. Cursor MCP Registry
+
+Cursor maintains a list of community MCP servers at https://docs.cursor.com/context/model-context-protocol. Listing is via a GitHub PR or a submission form (check the current Cursor docs for the live submission process, as it changes).
+
+### What to prepare
+
+Cursor's listing requires:
+- Server name, description, install command, and homepage URL.
+- Confirmation that the server follows MCP 2024-11 spec.
+- A working demo (optionally, a short screen recording).
+
+### Submission steps
+
+1. Check https://docs.cursor.com/context/model-context-protocol for the current submission mechanism (PR vs form).
+2. If PR-based, fork the relevant Cursor docs/registry repo and add an entry:
+   ```json
+   {
+     "name": "Nexatron",
+     "description": "AI analytics engine from dotSolved — ask questions about enterprise data in plain English. 12 tools including NL-to-SQL, semantic layer metrics, and RAG search.",
+     "install": "uvx nexatron-mcp",
+     "homepage": "https://nexatron.io",
+     "category": "data"
+   }
+   ```
+3. Include a link to `docs/integrations/claude-install.md#cursor` for the full Cursor install guide.
+4. Contact Cursor through their developer relations channel if a partnership tier listing is desired.
+
+### Cursor-specific config location
+
+For user reference, the Cursor config file is `.cursor/mcp.json` at the project root or `~/.cursor/mcp.json` for global scope. The `npx @nexatron/create-mcp --client cursor` command writes this file automatically.
+
+---
+
+## 4. Claude Desktop (Anthropic Connector Partner Program)
+
+Getting listed in the curated claude.ai connectors list (the built-in integration picker users see when they open Settings > Integrations) requires partnership approval from Anthropic's platform team. This is separate from the open directory submission in section 2.
+
+### What Anthropic requires
+
+From the Connector Partner Program application (based on public documentation as of April 2026):
+- Working remote MCP server accessible via HTTPS.
+- OAuth 2.1 with PKCE (the Nexatron backend already implements this).
+- RFC 8414 server metadata at `/.well-known/oauth-authorization-server`.
+- RFC 9728 protected resource metadata at `/.well-known/oauth-protected-resource`.
+- The server manifest at `/.well-known/mcp/server.json` (live at `https://api.nexatron.io/.well-known/mcp/server.json`).
+- Demonstrated security posture (SOC 2, pen test results, etc.).
+- A point of contact at the partner company.
+
+All of the above are either already built or documented in `docs/integrations/anthropic-directory-submission.md`.
+
+### Submission steps
+
+1. Email `partners@anthropic.com` with the subject: `Nexatron MCP Connector Partner Application`.
+2. Attach or link to `docs/integrations/anthropic-directory-submission.md` as the dossier.
+3. Confirm the remote MCP endpoint is live and the OAuth flow completes end-to-end (test with a claude.ai Pro account before submitting).
+4. Ashok Rao (founder, dotSolved) is the business contact; route partnership discussions through him.
+5. Nexatron Engineering (`nexatron@dotsolved.com`) handles technical questions.
+
+### Pre-flight for remote MCP
+
+Before submitting, verify:
+
+```bash
+# Manifest is live
+curl https://api.nexatron.io/.well-known/mcp/server.json | python3 -m json.tool
+
+# OAuth server metadata
+curl https://api.nexatron.io/.well-known/oauth-authorization-server | python3 -m json.tool
+
+# Protected resource metadata
+curl https://api.nexatron.io/.well-known/oauth-protected-resource | python3 -m json.tool
+```
+
+All three must return valid JSON with no 404/500. The MCP server endpoint itself:
+
+```bash
+# Should return 200 or 405 (not 404)
+curl -I https://api.nexatron.io/api/v1/mcp
+```
+
+---
+
+## 5. npm — publish `@nexatron/create-mcp`
+
+The scaffolding CLI in `packages/create-nexatron-mcp/` should be published to npm so users can run `npx @nexatron/create-mcp`.
+
+### Pre-flight checklist
+
+- [ ] Node tests pass: `cd packages/create-nexatron-mcp && node --test src/index.test.js`
+- [ ] Version in `package.json` is correct.
+- [ ] `bin.create-nexatron-mcp` points to `./src/index.js`.
+- [ ] `src/index.js` has `#!/usr/bin/env node` as the first line.
+
+### Publish steps
+
+```bash
+cd packages/create-nexatron-mcp
+
+# Dry run — shows what will be published
+npm pack --dry-run
+
+# Log in to npm (requires npm account with publish rights to @nexatron org)
+npm login
+
+# Publish under the @nexatron scope
+npm publish --access public
+```
+
+After publish, verify:
+
+```bash
+npx @nexatron/create-mcp --help
+```
+
+---
+
+## 6. Post-submission tracking
+
+| Registry | Status | Notes |
+|----------|--------|-------|
+| PyPI (`nexatron-mcp`) | Not published | Run publish steps above |
+| Anthropic open MCP directory | Not submitted | PR to modelcontextprotocol/servers |
+| Cursor MCP registry | Not submitted | Check current submission mechanism |
+| Anthropic Connector Partner | Not submitted | Email partners@anthropic.com |
+| npm (`@nexatron/create-mcp`) | Not published | Run npm publish steps above |
+
+Update this table as each submission progresses.
+
+---
+
+## 7. Keeping the manifest current
+
+The static manifest at `docs/integrations/nexatron-mcp-manifest.json` is the source of truth for the live endpoint at `https://api.nexatron.io/.well-known/mcp/server.json`. When tool names, scopes, or capabilities change:
+
+1. Update `docs/integrations/nexatron-mcp-manifest.json`.
+2. Update the backend route that serves it (check `app/api/wellknown.py`).
+3. Update the tool list in `packages/mcp-server/src/nexatron_mcp/server.py`.
+4. Bump the version in `packages/mcp-server/pyproject.toml` and `__init__.py`.
+5. Add a CHANGELOG entry.
+6. Notify any registered partner registries of the change (most accept simple re-submissions).