@functional-systems/lambdadb-mcp 0.1.0-dev.1

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## Unreleased
+
+- Prepare `@functional-systems/lambdadb-mcp` and the `lambdadb-mcp` executable for npm/npx distribution under Apache-2.0.
+- Add gated OIDC publishing for develop, rc and stable channels with exact tarball consumer checks.
+- Derive the MCP server version from package metadata and close the process on stdio disconnect or termination.
+- Raise the supported Node.js floor to 22.14.0; verify the minimum and current Node 22/24 LTS.
+- Preserve the existing environment variables, read-only default and explicit write opt-in.
+- Require explicit development-project confirmation before running the optional live smoke.
+- Refresh compatible locked dependencies; the audited dependency tree has no known advisories at validation time.

package/CONTRIBUTING.md

@@ -0,0 +1,56 @@
+# Contributing
+
+## Branches and validation
+
+Create a focused `feat/*` or `fix/*` branch from current `develop`; open PRs with
+`develop` explicitly selected as the base. Keep local credentials and unrelated
+changes outside the PR. Use a dedicated worktree when another checkout is in use.
+
+Use Node.js 22.14.0 or newer. CI verifies the exact minimum 22.14.0 and current
+22.x and 24.x LTS releases. Node 20 is end-of-life and is no longer supported.
+The runtime dependencies permit older Node versions (MCP SDK 1.29.0 declares
+Node >=18), but that is not a promise to support end-of-life runtimes. The
+22.14.0 floor also aligns with the CLI and npm's OIDC publishing runtime floor.
+See the [Node release schedule](https://nodejs.org/en/about/previous-releases)
+and [npm requirements](https://docs.npmjs.com/trusted-publishers/).
+
+```sh
+npm ci
+npm run check
+npm run test:package
+```
+
+`check` validates package/lock versions, type-checks, builds, and runs local tests.
+`test:package` packs once, checks the actual file inventory, installs without
+lifecycle scripts in a temporary consumer directory, and runs the MCP contracts
+against the installed executable over stdio. An optional tarball argument tests
+an already packed file without rebuilding it. Fixtures use loopback HTTP and
+synthetic credentials; they never call a LambdaDB service. Live verification is
+separate and requires explicit designation of a development project.
+
+The `CI` workflow in `.github/workflows/publish.yaml` runs for PRs and pushes to
+`develop`/`main`, manual validation and published GitHub Releases. Require the
+`Node.js 22.14.0`, `Node.js 22` and `Node.js 24` checks in branch protection;
+replace any old `Node 20*` / `Node 22` / `Node 24` check requirements when adopting
+this workflow. Branch protection is an administrator setup step, not configured
+by this change. Validation has read-only permissions and no service credentials.
+
+## Releases and compatibility
+
+Keep develop's reviewed base in `X.Y.Z-dev.N` form. Automatic dev publication
+requires separate bootstrap, package-specific npm trust and an explicit repository
+variable; it is initially disabled. PRs and manual workflow runs cannot publish.
+Follow [RELEASING.md](RELEASING.md) for every publication action.
+
+Prepare rc/stable metadata on a release branch and review it into `main`. Promote
+with merge commits to preserve main/develop ancestry. When synchronizing main
+back into develop through a PR, include the next dev base. Do not leave stable
+metadata on develop, where automatic version generation requires a dev version.
+Tags, GitHub Releases and bootstrap publication are explicit maintainer actions.
+
+Treat environment variables, tool names/schemas, read-only defaults, ref semantics,
+error handling and supported runtimes as public contracts. Document incompatible
+changes and validate the installed artifact. Update package.json and both root
+package-lock.json versions together with `npm version VERSION --no-git-tag-version`.
+Do not use prerelease channels as implicit write opt-in. Pin workflow actions to
+reviewed commit SHAs. Never commit keys, `.env` files or signed URLs.

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,289 @@
+# lambdadb-mcp
+
+MCP server for LambdaDB using the official TypeScript MCP SDK and the official LambdaDB TypeScript client.
+
+## Scope
+
+- Directly calls the LambdaDB data plane
+- Uses a single project-scoped API key from environment variables
+- Defaults to read-only tools
+- Optionally exposes write tools via an environment flag
+
+## Install and run with npm
+
+Package: `@functional-systems/lambdadb-mcp`. Executable: `lambdadb-mcp`.
+Requires Node.js >=22.14.0; CI tests the minimum and current Node 22/24 LTS.
+
+Publication is being prepared. The following commands become available after the
+maintainer completes [first publication and trust setup](RELEASING.md). Before
+there is a stable release, select `@dev` or an exact published prerelease:
+
+```sh
+npx --yes @functional-systems/lambdadb-mcp@dev
+# After a stable release exists:
+npm install -g @functional-systems/lambdadb-mcp
+lambdadb-mcp
+# Or run without a global installation:
+npx --yes @functional-systems/lambdadb-mcp
+```
+
+Set the environment variables below in your MCP client or securely in the parent
+process. Installed execution reads the environment directly and needs no checkout,
+build, shell script, or `.env.local`. It does not automatically load dotenv files.
+`LAMBDADB_ENV_FILE` belongs to the repository's development launchers only. If you
+prefer a file after global installation, use Node's explicit file loader:
+
+```sh
+node --env-file=/absolute/path/to/mcp.env "$(npm root -g)/@functional-systems/lambdadb-mcp/dist/index.js"
+```
+
+Exported environment values take precedence. Keep credentials out of command
+arguments, source control and logs. Pin an exact published version in MCP client
+configurations for reproducibility. `@dev`, `@rc` and unqualified (`latest`) resolve
+different release channels; installed copies do not update themselves.
+
+The server uses stdio: stdout contains only MCP JSON-RPC messages, diagnostics go
+to stderr, and stdin closure/SIGINT/SIGTERM ends the process. Running it without an
+MCP client waits for protocol input. See the [MCP transport specification](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports).
+
+## Project Structure
+
+```text
+src/
+├─ config/
+│  └─ env.ts
+├─ lambdadb/
+│  ├─ client.ts
+│  └─ errors.ts
+├─ server/
+│  └─ createServer.ts
+├─ tools/
+│  ├─ index.ts
+│  ├─ shared.ts
+│  ├─ read.ts
+│  └─ write.ts
+└─ index.ts
+```
+
+## Environment Variables
+
+```bash
+LAMBDADB_BASE_URL=https://aws-ap-northeast-2.lambdadb.ai
+LAMBDADB_PROJECT_NAME=my-project
+LAMBDADB_PROJECT_API_KEY=replace-me
+LAMBDADB_MCP_ENABLE_WRITE_TOOLS=false
+```
+
+## Available Tools
+
+Read-only:
+
+- `lambdadb_list_collections`
+- `lambdadb_get_collection`
+- `lambdadb_query_collection`
+- `lambdadb_list_docs`
+- `lambdadb_fetch_docs`
+
+Optional write tools:
+
+- `lambdadb_create_collection`
+- `lambdadb_upsert_docs`
+- `lambdadb_delete_docs`
+
+## API contract and tool inputs
+
+The LambdaDB SDK is pinned to `@functional-systems/lambdadb@0.5.1`.
+The tool contract was checked against LambdaDB develop
+[`d1a76659884a9ed09283a0b2e2989897dc799247`](https://github.com/lambdadb/lambdadb/commit/d1a76659884a9ed09283a0b2e2989897dc799247).
+This source revision does not establish which API revision is deployed.
+
+- Collection creation requires a nonempty `indexConfigs` and accepts `description`,
+  metadata `tags`, `partitionConfig`, and `snapshotRetentionInDays` (1–31).
+  The SDK validates individual index configurations and accepts HTTP 201 responses.
+- Query, Fetch, and List accept `ref: { kind: "branch" | "tag" | "alias", name: "..." }`.
+  Omitting `ref` reads from `main`. `consistentRead: true` is supported only by
+  Query/Fetch with an omitted ref or a direct Branch ref. List has no `consistentRead`.
+- List also accepts `filter`, `fields`, `includeVectors`, and `partitionFilter`.
+  The SDK selects the extended POST endpoint when needed and preserves pagination tokens.
+- Upsert/Delete accept an optional `branch`; omitting it writes to `main`.
+  Delete requires exactly one of a nonempty `ids` array or `filter`.
+- Unknown top-level inputs and unknown ref fields are rejected, so unsupported
+  selectors cannot silently fall back to `main`.
+- List/Get metadata no longer requires the removed `collectionStatus` or an absent
+  `dataUpdatedAt`. Epoch-millisecond timestamps are converted by the SDK to `Date`
+  and serialized as ISO strings in MCP text results.
+
+SDK 0.5.1 already includes the
+[`docsUrl` JSON-array fix](https://github.com/lambdadb/lambdadb-typescript-client/pull/26).
+Query/Fetch/List download top-level document arrays and retain legacy `{ "docs": [...] }`
+support without sending the project API key to the download URL. No additional SDK
+patch is needed for this issue.
+
+## Tests
+
+```bash
+npm ci
+npm run check
+npm run test:package
+```
+
+`check` runs type checking, a build, and the contract tests. Tests connect an MCP
+client to this server and exercise the installed SDK against a local HTTP fixture.
+They cover read-only defaults, write opt-in, List/Get response validation, creation
+HTTP 201, ref/branch forwarding, invalid combinations, pagination, and `docsUrl`
+arrays/errors and local environment-file loading. They do not require credentials
+or create remote collections. `test:package` additionally installs the actual
+tarball in a clean consumer directory and repeats the tool contracts over real
+stdio, checking version identity, config errors, stdout and process termination.
+CI validates Node 22.14.0, current 22.x and 24.x on PRs and pushes to develop/main.
+See [CONTRIBUTING.md](CONTRIBUTING.md) and [RELEASING.md](RELEASING.md) for checks,
+release policy and the initially disabled automatic publication gate.
+
+For a live smoke, explicitly designate a disposable **development** project and
+configure its credentials in `.env.local` with `LAMBDADB_MCP_ENABLE_WRITE_TOOLS=true`.
+An existing credential file alone is not permission to test. Then run:
+
+```bash
+LAMBDADB_RUN_LIVE_TESTS=1 LAMBDADB_LIVE_CONFIRM_PROJECT=YOUR_DEV_PROJECT npm run test:live
+```
+
+The live test creates one uniquely named temporary collection, checks real HTTP
+201/202 responses, metadata, pagination, filters, sorting, and Branch/Tag/Alias
+reads. It writes two 3 MiB documents to force actual `docsUrl` array downloads
+through the MCP tools and checks full payload integrity and download credential
+isolation. It allows up to five minutes for committed visibility, deletes its
+temporary collection in cleanup, and verifies that the collection is absent.
+Branch/Tag/Alias setup and collection cleanup use the SDK directly because these
+operations are not exposed as MCP tools. This test is separate from `npm run check`.
+
+If the environment file is outside the worktree:
+
+```bash
+LAMBDADB_ENV_FILE=/absolute/path/to/.env.local LAMBDADB_RUN_LIVE_TESTS=1 LAMBDADB_LIVE_CONFIRM_PROJECT=YOUR_DEV_PROJECT npm run test:live
+```
+
+## Run from source (development)
+
+Use Node.js >=22.14.0. The repository's optional launchers preserve exported
+environment overrides when loading dotenv files with Node's `--env-file`.
+
+If you use `nix-direnv`, this repo can provision Node automatically:
+
+```bash
+direnv allow
+```
+
+Or enter the shell directly:
+
+```bash
+nix develop
+```
+
+Then install and build:
+
+```bash
+npm install
+npm run build
+```
+
+For local development, create a `.env.local` file first:
+
+```bash
+cp .env.example .env.local
+```
+
+For local stdio execution:
+
+```bash
+export LAMBDADB_BASE_URL=...
+export LAMBDADB_PROJECT_NAME=...
+export LAMBDADB_PROJECT_API_KEY=...
+npm run start
+```
+
+Or load the local environment file:
+
+```bash
+npm run start:env
+```
+
+To inspect the server in the official MCP Inspector:
+
+```bash
+npm run inspect
+```
+
+`start:env`, `inspect`, and `test:live` use the same file selection:
+`LAMBDADB_ENV_FILE` when set, otherwise `.env.local` if present, otherwise `.env`.
+Only the selected file is loaded. For `start:env` and `test:live`, exported environment
+variables take precedence. Inspector forwards `LAMBDADB_ENV_FILE` and
+`LAMBDADB_MCP_ENABLE_WRITE_TOOLS`; its connection credentials come from the selected file.
+Relative `LAMBDADB_ENV_FILE` paths are resolved from the repository root.
+The Inspector launches `dist/index.js` through this loader and opens its web UI.
+Credentials are read by Node rather than passed as Inspector command-line arguments.
+
+To use read-only tools even when the selected file enables writes:
+
+```bash
+LAMBDADB_MCP_ENABLE_WRITE_TOOLS=false npm run inspect
+```
+
+## Codex Example
+
+After the first dev publication, configure the stdio executable:
+
+```toml
+[mcp_servers.lambdadb]
+command = "npx"
+args = ["--yes", "@functional-systems/lambdadb-mcp@dev"]
+
+[mcp_servers.lambdadb.env]
+LAMBDADB_BASE_URL = "https://aws-ap-northeast-2.lambdadb.ai"
+LAMBDADB_PROJECT_NAME = "my-project"
+LAMBDADB_PROJECT_API_KEY = "replace-me"
+LAMBDADB_MCP_ENABLE_WRITE_TOOLS = "false"
+```
+
+Use a secure local configuration or the client's environment forwarding facility
+for credentials. Replace `@dev` with an exact published version when pinning.
+The existing source-checkout launcher remains available as
+`bash /absolute/path/to/lambdadb-mcp/scripts/with-env.sh dist/index.js`.
+
+## Claude Desktop Example
+
+```json
+{
+  "mcpServers": {
+    "lambdadb": {
+      "command": "npx",
+      "args": ["--yes", "@functional-systems/lambdadb-mcp@dev"],
+      "env": {
+        "LAMBDADB_BASE_URL": "https://aws-ap-northeast-2.lambdadb.ai",
+        "LAMBDADB_PROJECT_NAME": "my-project",
+        "LAMBDADB_PROJECT_API_KEY": "replace-me",
+        "LAMBDADB_MCP_ENABLE_WRITE_TOOLS": "false"
+      }
+    }
+  }
+}
+```
+
+## Development Notes
+
+- This repo currently assumes `stdio` transport first for local MCP clients.
+- The server is scoped to one configured LambdaDB project per process.
+- Write tools are intentionally disabled by default.
+- `npm run inspect` is the fastest way to validate tool registration, schemas, and live LambdaDB responses during development.
+
+## Documentation Strategy
+
+Recommended split:
+
+- `lambdadb-mcp`: implementation-oriented source of truth
+- `docs`: user-facing setup, examples, supported tools, troubleshooting
+
+That keeps operational details close to code while avoiding product docs drift.
+
+## License
+
+Apache-2.0. See [LICENSE](LICENSE).

package/RELEASING.md

@@ -0,0 +1,180 @@
+# Releasing LambdaDB MCP
+
+## Status and policy
+
+This change prepares npm distribution; it does not publish a package, tag a
+release or enable automatic publication. On 2026-09-19, the public registry
+returned E404 for `@functional-systems/lambdadb-mcp`; GitHub had no tags or
+Releases. The current npm account returned E401 for both `npm whoami` and
+`npm org ls functional-systems`, so organization publication rights remain
+unconfirmed. GitHub repository administration is not npm organization membership.
+Check these again before bootstrap; a public E404 is not a name reservation.
+
+| Source | Version | Trigger | npm dist-tag |
+| --- | --- | --- | --- |
+| develop | `X.Y.Z-dev.N` | Successful push validation, explicitly enabled | dev |
+| reviewed main history | `X.Y.Z-rc.N` | Published GitHub prerelease `vX.Y.Z-rc.N` | rc |
+| reviewed main history | `X.Y.Z` | Published GitHub release `vX.Y.Z` | latest |
+
+Only these canonical forms are accepted, without leading zeroes or build suffixes.
+`package.json` and both root lockfile versions must match. MCP initialize reads
+its version from the installed package.json; there is no second version constant.
+The repository URL must identify this exact public GitHub repository.
+
+## Validation and the publication artifact
+
+From a clean checkout of the reviewed candidate with Node >=22.14.0:
+
+```sh
+npm ci
+npm run check
+# Use an output directory outside the checkout.
+mkdir -p /tmp/lambdadb-mcp-release
+npm pack --json --pack-destination /tmp/lambdadb-mcp-release
+# Substitute the exact filename returned by npm pack.
+npm run test:package -- /tmp/lambdadb-mcp-release/functional-systems-lambdadb-mcp-VERSION.tgz
+```
+
+Keep that tarball: publish the same file, never a newly packed directory. The
+workflow performs exactly one pack in its publishing job, validates inventory,
+installs that file without install scripts into a clean temporary directory,
+and tests the installed `lambdadb-mcp` bin. Its hash must remain unchanged during
+testing. Validation matrix jobs also test their own packages; those are not the
+publication artifact. Only compiled JavaScript, package metadata, README,
+CHANGELOG, contribution/release guides and LICENSE are allowed in the actual tarball. The build cleans dist
+first so stale compiled files cannot survive a normal pack.
+
+Consumer tests exercise MCP initialize, tools/list and tools/call with loopback
+HTTP fixtures: read-only defaults, write opt-in, ref/branch forwarding, SDK errors,
+docsUrl downloads and credential isolation, version identity, configuration
+failures, protocol-only stdout and termination. They do not prove production
+service behavior or every MCP client UI. Installed dependencies are resolved by
+npm (the package's development lockfile is not a consumer dependency lock).
+
+Live tests are optional for PR validation, but release owners must explicitly
+record performed or not performed. They require a designated development project,
+not merely the presence of an existing `.env.local` or credential. See README
+for `LAMBDADB_RUN_LIVE_TESTS=1` and project confirmation. Do not load production
+credentials into package/CI tests. This implementation task did not run live tests.
+
+## First package publication: separate manual bootstrap
+
+npm trust configuration requires an existing package. See the official
+[npm trust prerequisites](https://docs.npmjs.com/cli/v11/commands/npm-trust/).
+The TypeScript SDK's or CLI's trust settings do not cover this package.
+
+1. Review and merge preparation, validate a clean reviewed develop candidate,
+   and confirm its version is the real bootstrap prerelease `0.1.0-dev.1`.
+2. Obtain authorization for first publication. An authorized npm
+   `functional-systems` organization owner uses interactive `npm login` with MFA,
+   then verifies `npm whoami` and `npm org ls functional-systems`. Do not add a
+   long-lived npm token to GitHub or the repository.
+3. Pack once and test the resulting file using the commands above. Publish that
+   exact verified file with the interactive account:
+
+   ```sh
+   npm publish /absolute/path/to/functional-systems-lambdadb-mcp-0.1.0-dev.1.tgz --access public --tag dev
+   ```
+
+4. Verify version, tarball integrity, dist-tags and a clean consumer install.
+   Bootstrap does not carry GitHub Actions provenance. npm can also assign
+   `latest` during first publication even with `--tag dev`; inspect actual tags
+   and document that state. Until a stable release exists, use an explicit dev
+   version/tag and do not advertise unqualified npx as stable. Do not repeat
+   bootstrap or republish a used version to fix registry lag.
+
+## Configure package-specific Trusted Publishing
+
+After bootstrap, open the npm package's **Settings → Trusted Publisher**:
+
+| Setting | Value |
+| --- | --- |
+| Package | `@functional-systems/lambdadb-mcp` |
+| Provider | GitHub Actions |
+| Organization or user | `lambdadb` |
+| Repository | `lambdadb-mcp` |
+| Workflow filename | `publish.yaml` (filename only) |
+| Environment | Empty; the job declares no GitHub Environment |
+| Allowed actions | Enable direct `npm publish` |
+
+New trust configurations may default to staged publishing only; that does not
+authorize this workflow's direct publish. If an Environment is added later,
+configure its exact name in npm too. Restrict traditional publishing tokens in
+package settings after setup. Saving trust settings does not validate OIDC;
+only an authorized successful publication does.
+
+The workflow uses a GitHub-hosted runner, Node 24, npm >=11.5.1,
+`id-token: write` only in the publication job, public access and provenance.
+It has no npm token secret. See [npm Trusted Publishing](https://docs.npmjs.com/trusted-publishers/).
+
+## Enable automatic dev publication: a separate authorization
+
+Leave repository variable `NPM_DEV_PUBLISH_ENABLED` unset or false through
+bootstrap and trust setup. Only after authorizing ongoing develop publication,
+set it to `true` in GitHub **Settings → Secrets and variables → Actions → Variables**.
+This implementation leaves it unset. The next eligible develop push, or a rerun
+of its existing push workflow, can then publish. `workflow_dispatch`, PRs and main
+pushes validate only. Disable the variable to stop future automatic publication;
+do not cancel an in-progress registry write as rollback.
+
+The generator reuses the CLI's first-parent strategy: for a reviewed base
+`X.Y.Z-dev.N`, set N to `git rev-list --first-parent --count HEAD` from a full
+checkout. Numbers can have gaps; reruns of the same commit generate the same
+version. Disable force pushes/history rewrites. Generated package/lock versions
+and gitHead exist only in the runner; no version commits, tags or GitHub Releases
+are created for dev builds. Review a new base when starting another release line.
+
+Remote develop HEAD is checked before preparation and immediately before the
+write. Stale jobs and versions older than the current channel are skipped.
+All publication jobs share non-cancelling concurrency so registry writes do not
+race. A newer pending job can replace an older pending job; this does not promise
+a package for every rapid merge. Re-run an explicit release if it was superseded
+in the pending queue and still needs publication.
+
+## Explicit rc/stable publication
+
+1. Prepare matching package/lock metadata and a dated
+   `## [VERSION] - YYYY-MM-DD` changelog entry on a release branch. Review into
+   main and retain validation/live-test status for the candidate.
+2. Ensure `publish.yaml` exists on the default branch (`main`). The dev push
+   path does not require that promotion, but GitHub Release handling does.
+3. Obtain authorization, tag the verified main commit as `vVERSION`, and publish
+   the GitHub Release with `prerelease: true` for rc or `false` for stable.
+   Draft releases do not publish. Do not create a dev GitHub Release.
+4. The workflow validates the release tag, package versions, prerelease flag,
+   changelog and ancestry in origin/main; it packs/tests once and publishes the
+   exact file to rc/latest with OIDC and provenance. A successful CI run alone
+   is not publication evidence. Verify npm and synchronize release changes into
+   develop with its next dev base via PR.
+
+## Duplicate prevention, registry lag and recovery
+
+Dev, rc and stable use the CLI-derived registry verification path. Before a write,
+only a structured E404 means an absent version; authentication, malformed responses
+and transport failures fail closed. Existing versions must match package name,
+version, gitHead and tarball SHA-512 integrity and already own the selected tag.
+Identical reruns report `already-published`; conflicts or unexpected tag state
+require investigation. Older channel candidates report `superseded` without
+changing tags. rc/dev never intentionally update latest.
+
+There is at most one publish request per invocation, with no automatic write
+retry. After an accepted write, read requests share a five-minute monotonic budget,
+15-second maximum request timeouts, no nested npm fetch retries and sleeps of at
+most ten seconds. E404, HTTP 429/5xx and recognized transient connection errors
+are retried only during post-publication reads. Metadata and tags can propagate
+separately. Artifact conflicts, authentication errors and malformed responses fail.
+
+`published-verification-pending` means the write succeeded but reads did not
+converge in the budget. A failed publish request is an uncertain write. In either
+case inspect and retry registry reads first, never immediately republish:
+
+```sh
+npm view @functional-systems/lambdadb-mcp@VERSION version gitHead dist.integrity dist.attestations --json
+npm view @functional-systems/lambdadb-mcp@dev dist-tags --json
+```
+
+Once metadata agrees, an identical rerun skips the write. Verify provenance's
+repository and commit and run a clean consumer smoke. Do not move immutable tags,
+republish a used version, or automatically change dist-tags to recover. Prepare a
+new reviewed patch for a bad release; deprecation and tag changes are explicit
+maintainer actions. No Homebrew, MCP Registry or HTTP hosting is part of this flow.

package/dist/config/env.js

@@ -0,0 +1,27 @@
+function requireEnv(name, value) {
+    if (!value || value.trim() === "") {
+        throw new Error(`Missing required environment variable: ${name}`);
+    }
+    return value.trim();
+}
+function parseBoolean(value, fallback) {
+    if (value == null || value.trim() === "") {
+        return fallback;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    throw new Error(`Invalid boolean value: ${value}`);
+}
+export function getEnvConfig(env = process.env) {
+    return {
+        baseUrl: requireEnv("LAMBDADB_BASE_URL", env.LAMBDADB_BASE_URL),
+        projectName: requireEnv("LAMBDADB_PROJECT_NAME", env.LAMBDADB_PROJECT_NAME),
+        projectApiKey: requireEnv("LAMBDADB_PROJECT_API_KEY", env.LAMBDADB_PROJECT_API_KEY),
+        enableWriteTools: parseBoolean(env.LAMBDADB_MCP_ENABLE_WRITE_TOOLS, false)
+    };
+}

package/dist/index.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { getEnvConfig } from "./config/env.js";
+import { createServer } from "./server/createServer.js";
+async function main() {
+    const config = getEnvConfig();
+    const server = createServer(config);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // A disconnected stdio client owns no further work in this process.
+    const shutdown = () => {
+        void server.close().finally(() => process.exit(0));
+    };
+    process.stdin.once("end", shutdown);
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+});

package/dist/lambdadb/client.js

@@ -0,0 +1,8 @@
+import { LambdaDBClient } from "@functional-systems/lambdadb";
+export function createLambdaDBClient(config) {
+    return new LambdaDBClient({
+        baseUrl: config.baseUrl,
+        projectName: config.projectName,
+        projectApiKey: config.projectApiKey
+    });
+}

package/dist/lambdadb/errors.js

@@ -0,0 +1,14 @@
+export function formatLambdaDBError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    try {
+        return JSON.stringify(error, null, 2);
+    }
+    catch {
+        return "Unknown LambdaDB error";
+    }
+}

package/dist/server/createServer.js

@@ -0,0 +1,13 @@
+import { readFileSync } from "node:fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerTools } from "../tools/index.js";
+export function createServer(config) {
+    const server = new McpServer({
+        name: "lambdadb-mcp",
+        version: JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version
+    }, {
+        instructions: "This server exposes LambdaDB data plane tools for a single configured project. Prefer read-only tools unless write tools are explicitly enabled by the server operator."
+    });
+    registerTools(server, config);
+    return server;
+}

package/dist/tools/index.js

@@ -0,0 +1,8 @@
+import { registerReadTools } from "./read.js";
+import { registerWriteTools } from "./write.js";
+export function registerTools(server, config) {
+    registerReadTools(server, config);
+    if (config.enableWriteTools) {
+        registerWriteTools(server, config);
+    }
+}

package/dist/tools/read.js

@@ -0,0 +1,153 @@
+import { z } from "zod";
+import { createLambdaDBClient } from "../lambdadb/client.js";
+import { formatLambdaDBError } from "../lambdadb/errors.js";
+import { fieldsSchema, jsonResult, nameSchema, partitionFilterSchema, readOptions, readRefSchema } from "./shared.js";
+export function registerReadTools(server, config) {
+    server.registerTool("lambdadb_list_collections", {
+        title: "List Collections",
+        description: "List collections in the configured LambdaDB project.",
+        annotations: {
+            readOnlyHint: true,
+            openWorldHint: false
+        },
+        inputSchema: z.strictObject({
+            size: z.number().int().min(1).max(100).optional(),
+            pageToken: z.string().optional()
+        })
+    }, async ({ size, pageToken }) => {
+        try {
+            const client = createLambdaDBClient(config);
+            const result = await client.listCollections({ size, pageToken });
+            return jsonResult("Collections listed successfully.", result);
+        }
+        catch (error) {
+            throw new Error(formatLambdaDBError(error));
+        }
+    });
+    server.registerTool("lambdadb_get_collection", {
+        title: "Get Collection",
+        description: "Get metadata for a specific collection.",
+        annotations: {
+            readOnlyHint: true,
+            openWorldHint: false
+        },
+        inputSchema: z.strictObject({
+            collectionName: nameSchema
+        })
+    }, async ({ collectionName }) => {
+        try {
+            const client = createLambdaDBClient(config);
+            const result = await client.collection(collectionName).get();
+            return jsonResult("Collection metadata loaded successfully.", result);
+        }
+        catch (error) {
+            throw new Error(formatLambdaDBError(error));
+        }
+    });
+    server.registerTool("lambdadb_query_collection", {
+        title: "Query Collection",
+        description: "Run a search query against a collection and return the matching documents.",
+        annotations: {
+            readOnlyHint: true,
+            openWorldHint: false
+        },
+        inputSchema: z.strictObject({
+            collectionName: nameSchema,
+            size: z.number().int().min(1).max(100).optional(),
+            query: z.record(z.string(), z.any()),
+            ref: readRefSchema.optional(),
+            consistentRead: z.boolean().optional().describe("true requires a direct branch ref or omitted ref (main)."),
+            includeVectors: z.boolean().optional(),
+            // JSON Schema conversion drops RegExp flags; encode case folding in the pattern.
+            sort: z.array(z.record(z.string(), z.string().regex(/^([aA][sS][cC]|[dD][eE][sS][cC])$/))).optional(),
+            fields: fieldsSchema.optional(),
+            partitionFilter: partitionFilterSchema.optional()
+        })
+    }, async ({ collectionName, size, query, ref, consistentRead, includeVectors, sort, fields, partitionFilter }) => {
+        try {
+            const client = createLambdaDBClient(config);
+            const input = {
+                query,
+                size,
+                ...readOptions(ref, consistentRead),
+                includeVectors,
+                sort,
+                fields,
+                partitionFilter
+            };
+            const result = await client.collection(collectionName).query(input);
+            return jsonResult("Collection query completed successfully.", result);
+        }
+        catch (error) {
+            throw new Error(formatLambdaDBError(error));
+        }
+    });
+    server.registerTool("lambdadb_list_docs", {
+        title: "List Documents",
+        description: "List documents from a collection with pagination support.",
+        annotations: {
+            readOnlyHint: true,
+            openWorldHint: false
+        },
+        inputSchema: z.strictObject({
+            collectionName: nameSchema,
+            size: z.number().int().min(1).max(100).optional(),
+            pageToken: z.string().optional(),
+            ref: readRefSchema.optional(),
+            filter: z.record(z.string(), z.any()).optional(),
+            fields: fieldsSchema.optional(),
+            includeVectors: z.boolean().optional(),
+            partitionFilter: partitionFilterSchema.optional()
+        })
+    }, async ({ collectionName, size, pageToken, ref, filter, fields, includeVectors, partitionFilter }) => {
+        try {
+            const client = createLambdaDBClient(config);
+            const result = await client.collection(collectionName).docs.list({
+                size,
+                pageToken,
+                ref,
+                filter,
+                fields,
+                includeVectors,
+                partitionFilter
+            });
+            return jsonResult("Documents listed successfully.", result);
+        }
+        catch (error) {
+            throw new Error(formatLambdaDBError(error));
+        }
+    });
+    server.registerTool("lambdadb_fetch_docs", {
+        title: "Fetch Documents",
+        description: "Fetch specific documents from a collection by document ID.",
+        annotations: {
+            readOnlyHint: true,
+            openWorldHint: false
+        },
+        inputSchema: z.strictObject({
+            collectionName: nameSchema,
+            ids: z.array(z.string().min(1)).min(1).max(100),
+            ref: readRefSchema.optional(),
+            consistentRead: z.boolean().optional().describe("true requires a direct branch ref or omitted ref (main)."),
+            includeVectors: z.boolean().optional(),
+            fields: fieldsSchema.optional(),
+            partitionFilter: partitionFilterSchema.optional()
+        })
+    }, async ({ collectionName, ids, ref, consistentRead, includeVectors, fields, partitionFilter }) => {
+        try {
+            const client = createLambdaDBClient(config);
+            const input = {
+                ids,
+                ...readOptions(ref, consistentRead),
+                includeVectors,
+                fields,
+                partitionFilter
+            };
+            const result = await client.collection(collectionName).docs.fetch(input);
+            return jsonResult("Documents fetched successfully.", result);
+        }
+        catch (error) {
+            throw new Error(formatLambdaDBError(error));
+        }
+    });
+}

package/dist/tools/shared.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export const nameSchema = z.string().regex(/^[a-zA-Z0-9_-]{3,52}$/);
+export const readRefSchema = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("branch"), name: nameSchema }),
+    z.strictObject({ kind: z.literal("tag"), name: nameSchema }),
+    z.strictObject({ kind: z.literal("alias"), name: nameSchema })
+]);
+const fieldNames = z.array(z.string().min(1)).min(1);
+export const fieldsSchema = z.union([
+    z.strictObject({ include: fieldNames, exclude: fieldNames.optional() }),
+    z.strictObject({ include: fieldNames.optional(), exclude: fieldNames })
+]);
+export const partitionFilterSchema = z.strictObject({
+    field: z.string().min(1),
+    in: z.array(z.string().min(1)).min(1)
+});
+// Preserve the SDK's discriminated input type after enforcing the ref constraint.
+export function readOptions(ref, consistentRead) {
+    if (ref && ref.kind !== "branch") {
+        if (consistentRead === true) {
+            throw new Error("consistentRead=true requires a direct branch ref (or omitted ref for main).");
+        }
+        return { ref, consistentRead };
+    }
+    return { ref, consistentRead };
+}
+export function jsonResult(title, data) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${title}\n\n${JSON.stringify(data, null, 2)}`
+            }
+        ]
+    };
+}

package/dist/tools/write.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { createLambdaDBClient } from "../lambdadb/client.js";
+import { formatLambdaDBError } from "../lambdadb/errors.js";
+import { jsonResult, nameSchema, partitionFilterSchema } from "./shared.js";
+export function registerWriteTools(server, config) {
+    server.registerTool("lambdadb_create_collection", {
+        title: "Create Collection",
+        description: "Create a new collection in the configured project.",
+        annotations: {
+            openWorldHint: false
+        },
+        inputSchema: z.strictObject({
+            collectionName: nameSchema,
+            indexConfigs: z.record(z.string(), z.any()).refine((value) => Object.keys(value).length > 0, "indexConfigs must contain at least one field."),
+            description: z.string().max(255).optional(),
+            tags: z.record(z.string().regex(/^[A-Za-z0-9_.-]{1,63}$/), z.string().min(1).max(127).regex(/^[^:#,]+$/))
+                .refine((value) => Object.keys(value).length <= 5, "At most five tags are allowed.")
+                .optional(),
+            snapshotRetentionInDays: z.number().int().min(1).max(31).optional(),
+            partitionConfig: z.strictObject({
+                fieldName: z.string().min(1),
+                dataType: z.literal("keyword"),
+                numPartitions: z.number().int().min(2).max(1024)
+            }).optional()
+        })
+    }, async ({ collectionName, indexConfigs, description, tags, snapshotRetentionInDays, partitionConfig }) => {
+        try {
+            const client = createLambdaDBClient(config);
+            const input = {
+                collectionName,
+                indexConfigs,
+                description,
+                tags,
+                snapshotRetentionInDays,
+                partitionConfig
+            };
+            const result = await client.createCollection(input);
+            return jsonResult("Collection created successfully.", result);
+        }
+        catch (error) {
+            throw new Error(formatLambdaDBError(error));
+        }
+    });
+    server.registerTool("lambdadb_upsert_docs", {
+        title: "Upsert Documents",
+        description: "Upsert documents into a collection. Keep payloads small enough for the standard API path.",
+        annotations: {
+            openWorldHint: false
+        },
+        inputSchema: z.strictObject({
+            collectionName: nameSchema,
+            docs: z.array(z.record(z.string(), z.any())).min(1),
+            branch: nameSchema.optional()
+        })
+    }, async ({ collectionName, docs, branch }) => {
+        try {
+            const client = createLambdaDBClient(config);
+            const input = { docs, branch };
+            const result = await client.collection(collectionName).docs.upsert(input);
+            return jsonResult("Documents upserted successfully.", result);
+        }
+        catch (error) {
+            throw new Error(formatLambdaDBError(error));
+        }
+    });
+    server.registerTool("lambdadb_delete_docs", {
+        title: "Delete Documents",
+        description: "Delete documents using exactly one of ids or filter. Omitted branch targets main.",
+        annotations: {
+            openWorldHint: false
+        },
+        inputSchema: z.strictObject({
+            collectionName: nameSchema,
+            ids: z.array(z.string().min(1)).min(1).optional(),
+            filter: z.record(z.string(), z.any()).optional(),
+            partitionFilter: partitionFilterSchema.optional(),
+            branch: nameSchema.optional()
+        })
+    }, async ({ collectionName, ids, filter, partitionFilter, branch }) => {
+        if ((ids === undefined) === (filter === undefined)) {
+            throw new Error("Specify exactly one of ids or filter.");
+        }
+        try {
+            const client = createLambdaDBClient(config);
+            const input = ids !== undefined
+                ? { ids, partitionFilter, branch }
+                : { filter: filter, partitionFilter, branch };
+            const result = await client.collection(collectionName).docs.delete(input);
+            return jsonResult("Documents deleted successfully.", result);
+        }
+        catch (error) {
+            throw new Error(formatLambdaDBError(error));
+        }
+    });
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@functional-systems/lambdadb-mcp",
+  "version": "0.1.0-dev.1",
+  "private": false,
+  "description": "MCP server for LambdaDB data plane",
+  "type": "module",
+  "engines": {
+    "node": ">=22.14.0"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json && node -e \"require('node:fs').chmodSync('dist/index.js', 0o755)\"",
+    "check": "npm run check:version && npm run typecheck && npm test",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "test:live": "npm run build && bash ./scripts/with-env.sh --test test/integration/live.test.mjs",
+    "dev": "tsx watch src/index.ts",
+    "inspect": "bash ./scripts/inspect.sh",
+    "start": "node dist/index.js",
+    "start:env": "bash ./scripts/with-env.sh dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepack": "npm run build",
+    "check:version": "node scripts/check-release.mjs",
+    "test:package": "node scripts/test-package.mjs"
+  },
+  "dependencies": {
+    "@functional-systems/lambdadb": "0.5.1",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@types/node": "^22.12.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.8.3"
+  },
+  "bin": {
+    "lambdadb-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "RELEASING.md"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lambdadb/lambdadb-mcp.git"
+  },
+  "homepage": "https://github.com/lambdadb/lambdadb-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/lambdadb/lambdadb-mcp/issues"
+  },
+  "keywords": [
+    "lambdadb",
+    "mcp",
+    "model-context-protocol"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
+}