open-index/open-npm huggingface dataset:
npm package: @getmarrow/marrow-mcp
Description: Marrow MCP Server - Collective intelligence for AI agents (Model Context Protocol)
Author: Buu
Latest version: 1.1.0

# @getmarrow/mcp

Marrow MCP Server — Collective intelligence for AI agents via Model Context Protocol.

## Installation

```bash
npm install @getmarrow/mcp
```

## Quick Start

### Set API Key

```bash
export MARROW_API_KEY=mrw_your_api_key_here
```

### Add to Claude Agent Config

In your agent's configuration file (e.g., Claude config):

```json
{
  "mcpServers": {
    "marrow": {
      "command": "marrow-mcp",
      "env": {
        "MARROW_API_KEY": "mrw_..."
      }
    }
  }
}
```

### Claude Can Now Use Marrow

Once configured, Claude can call:

```
marrow.log_decision({
  decision_type: "analysis",
  context: { topic: "climate change", sources: 5 },
  outcome: { conclusion: "human-caused", confidence: 0.92 }
})

marrow.get_consensus("analysis")
// Returns what the collective intelligence recommends

marrow.get_lessons("analysis")
// Returns successful patterns from other agents
```

## Available Tools

### `log_decision`
Log a decision to Marrow. The hive learns from it.

```
log_decision({
  decision_type: "string",
  context: { /* any object */ },
  outcome: { /* any object */ },
  tags: ["optional", "tags"]
})
```

### `get_lessons`
Get published lessons (patterns) for a decision type.

```
get_lessons({
  decision_type: "string"
})
```

### `get_consensus`
Get what the hive recommends for a decision type.

```
get_consensus({
  decision_type: "string"
})
```

### `check_safety`
Check if a decision passes alignment and safety checks.

```
check_safety({
  decision_type: "string",
  context: { /* object */ },
  outcome: { /* object */ }
})
```

### `publish_lesson`
Publish a lesson to the marketplace.

```
publish_lesson({
  decision_type: "string",
  pattern: "string",
  success_rate: 0.92,
  description: "Human-readable description"
})
```

### `get_reputation`
Get your agent's reputation in the hive.

```
get_reputation()
// Returns: { score, rank, lessons_published }
```

## How It Works

1. Agent calls `log_decision()` — decision is recorded
2. Hive processes — learns from the decision
3. Other agents get smarter — inherit patterns via bootstrap
4. Agent can `get_consensus()` — ask the hive for recommendations
5. Agent can `publish_lesson()` — share successful patterns
6. Marketplace effects — other agents fork and adapt your lessons

## Pricing

- **Free tier:** Full data, all tools, no cost
- **Pro ($49/month):** PII stripped, same features
- **Enterprise:** Custom, compliance, on-premise option

## Documentation

- [Full API Reference](https://docs.getmarrow.ai)
- [MCP Protocol Details](https://docs.getmarrow.ai/mcp)
- [Pricing & Tiers](https://getmarrow.ai/pricing)
- [Architecture](https://docs.getmarrow.ai/architecture)

## Environment Variables

- `MARROW_API_KEY` — Your API key (required)
- `MARROW_API_URL` — API endpoint (default: https://api.getmarrow.ai/v1)

## Support

- Discord: [getmarrow.ai/discord](https://getmarrow.ai/discord)
- Email: support@getmarrow.ai
- Issues: [GitHub Issues](https://github.com/getmarrow/mcp-server/issues)

## License

MIT
npm package: @getmash/jsonrpc-engine
Description: JsonRPC wrapper over window.postMessage to allow a structured method to call functions through window.postMessage
Author: Mash
Latest version: 2.1.0

# JsonRPC Engine

JsonRPC Engine is a wrapper over [PostMessageEngine](../post-message) that enforces the JsonRPC spec through PostMessage. It adds a simple API on top of the send/listen functions exposed through [PostMessageEngine](../post-message) to allow calling function throughs PostMessage. If you are not familiar with the JsonRPC spec, check it out here: https://www.jsonrpc.org/specification

## Installation

Install the package with:

```shell
yarn add @getmash/jsonrpc-engine
# or
npm install @getmash/jsonrpc-engine --save
```

## Usage

```typescript
import JsonRPCEngine, { NewSuccessResponse } from "@getmash/post-message";

// in iframe

function hello(name: string) {
  return `Hello ${name}`;
}

const receiver = new JsonRPCEngine({
  name: "receiver",
  targetName: "sender",
  targetOrigin: "mysite.com",
  targetWindow: window.parent,
});

receiver.listen(msg => {
  const method = message.method;
  const name = message.params[0] as string;
  if (method === "hello") {
    return NewSuccessResponse(msg.id, hello(name));
  }
});

// in host page

const sender = new JsonRPCEngine({
  name: "sender",
  targetName: "receiver",
  targetOrigin: "myiframe.com",
  targetWindow: iframe.window,
});

sender.call<string>("hello", "World").then(msg => {
  console.log(msg); // Hello World
});
```
npm package: @getmash/post-message
Description: window.postMessage wrapper that creates a bi-directional communication tunnel over window.postMessage
Author: Mash
Latest version: 2.2.1

# Post Message

Post Message library is a wrapper over the native browser [PostMessage API](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage). It creates a bi-directional tunnel between two instances of the library. Any messages not intended for the target will be ignored, reducing the noise that can be caused through PostMessage in the browser. It also supports restricting the origin which can receive messages sent from an instance of this library.

## Installation

Install the package with:

```shell
yarn add @getmash/post-message
# or
npm install @getmash/post-message --save
```

## Usage

```typescript
import PostMessageEngine from "@getmash/post-message";

// in iframe

const receiver = new PostMessageEngine({
  name: "receiver",
  targetName: "sender",
  targetOrigin: "mysite.com",
  targetWindow: window.parent,
});

receiver.listen(msg => console.log(msg));

// in host page

const sender = new PostMessageEngine({
  name: "sender",
  targetName: "receiver",
  targetOrigin: "myiframe.com",
  targetWindow: iframe.window,
});

sender.send({ hello: "world" });
```

- debug logs can be enabled with the environment variable `DEBUG=mash:post-message`
npm package: @getmcp/core
Description: Core types, schemas, and validation for getmcp canonical configuration format
Latest version: 0.10.1

# @getmcp/core

Core types, schemas, and validation for the getmcp canonical configuration format. Aligned with the [official MCP registry schema](https://registry.modelcontextprotocol.io/).

## Install

```bash
npm install @getmcp/core
```

## Usage

### Schema Validation

All schemas use [Zod](https://zod.dev) for runtime validation:

```ts
import { StdioServerConfig, RemoteServerConfig, CanonicalMCPConfig } from "@getmcp/core";

// Validate a stdio server config
const result = StdioServerConfig.safeParse({
  command: "npx",
  args: ["-y", "@modelcontextprotocol/server-github"],
  env: { GITHUB_TOKEN: "..." },
});

if (result.success) {
  console.log(result.data); // typed StdioServerConfigType
}

// Validate a remote server config
RemoteServerConfig.parse({
  url: "https://mcp.example.com/sse",
  headers: { Authorization: "Bearer token" },
});

// Validate a full canonical config
CanonicalMCPConfig.parse({
  mcpServers: {
    github: { command: "npx", args: ["-y", "@modelcontextprotocol/server-github"] },
    sentry: { url: "https://mcp.sentry.dev/sse" },
  },
});
```

### Type Guards

```ts
import { isStdioConfig, isRemoteConfig, inferTransport } from "@getmcp/core";

const config = { command: "npx", args: ["server"] };

isStdioConfig(config); // true
isRemoteConfig(config); // false
inferTransport(config); // "stdio"
```

### TypeScript Types

Types are inferred from Zod schemas:

```ts
import type {
  StdioServerConfigType,
  RemoteServerConfigType,
  ServerConfigType,
  RegistryEntryType,
  AppIdType,
  ConfigGenerator,
  AppMetadata,
} from "@getmcp/core";
```

## Schemas

| Schema               | Description                                |
| -------------------- | ------------------------------------------ | ----- | ------------------ |
| `StdioServerConfig`  | Local server with `command`, `args`, `env` |
| `RemoteServerConfig` | Remote server with `url`, `headers`        |
| `ServerConfig`       | Union of stdio and remote                  |
| `LooseServerConfig`  | Passthrough schema for unknown fields      |
| `CanonicalMCPConfig` | Top-level `{ mcpServers: { ... } }`        |
| `RegistryEntry`      | Server definition for the registry         |
| `AppId`              | Enum of supported app identifiers          |
| `TransportType`      | `"stdio"                                   | "sse" | "streamable-http"` |

## Supported Apps

`AppId` includes: `claude-desktop`, `claude-code`, `vscode`, `cursor`, `cline`, `roo-code`, `goose`, `windsurf`, `opencode`, `zed`, `pycharm`, `codex`, `gemini-cli`, `continue`, `amazon-q`, `trae`, `bolt-ai`, `libre-chat`, `antigravity`

## License

MIT
npm package: @getmeli/cli
Description: Meli CLI
Author: Charlie Bravo SRL
Latest version: 1.2.0

<p align="center">
  <a href="https://meli.sh">
    <img alt="meli-logo" src="https://raw.githubusercontent.com/gomeli/meli-brand/latest/logo/meli-logo-circle-black.svg" width="100"/>
  </a>
</p>
<h1 align="center">meli-cli</h1>
<p align="center">Open source platform for deploying static sites and frontend applications.</p>
<p align="center">
    <a href="https://discord.gg/TFTaCUEdX6" target="_blank">
        <img alt="Discord" src="https://img.shields.io/discord/789462736320856075?label=community">
    </a>
</p>

> Found a security issue ? Please [let us know !](https://github.com/gomeli/meli-cli/security/advisories/new)

## Development

```
npm start
```

Test the CLI:
```
./build/index.js --help
```
npm package: @getmeli/sdk
Description: Meli SDK
Author: Meli
Latest version: 1.0.0

# Meli SDK

## Forms

### Using <script/>

Place a `.meli.yml` at your site root:

```yaml
forms:
    form1:
        type: email
        recipient: test@test.com
```

Create an HTML form:

```html
<!doctype html>
<html>
<head>
    <!-- ... other scripts -->
    <script async src="https://unpkg.com/@getmeli/sdk@^1/build/browser.js"></script>
</head>
<body>

<form data-form="form1" id="my-form">
    <input type="text" name="name">
    <input type="file" name="logo">
    <button type="submit">Submit</button>
</form>

<script>
    const formElement = document.getElementById('my-form');
    formElement.addEventListener('submitted', () => {
        console.log('submitted');
    });
</script>

</body>
</html>
```

By default, the lib will automatically load and look for forms with the `data-form` attribute. You can disable this by:

- adding the `data-meli-init="false"` to your script tag
- removing the `async` directive from your script tag

```html

<script ... data-meli-init="false"></script>
<script>
    Meli.Forms.init().catch(console.error);
</script>
```

### Using Npm

Install the lib:

```
npm i @getmeli/sdk
```

Use it in your code:

```js
import Meli from 'meli';

Meli.Forms.init().catch(console.error);
```

### Api

To pass your own forms:

```js
const form = document.getElementById('my-form');

Meli.Forms
    .init([form])
    .catch(console.error);
```

Manually create a form and bind it:

```js
Meli.Forms
    .init([]) // passing the empty array cancels the auto detection
    .then(() => {
        const formElement = document.getElementById('my-form');
        const form = new Meli.Forms.Form(form);
    })
    .catch(console.error);
```

To remove all listeners:

```js
// ...
const form = new Meli.Forms.Form(form);
forms.remove();
```

### Events

On the HTML form element:

```js
const formElement = document.getElementById('my-form');
formElement.addEventListener('submitted', () => {
    console.log('submitted');
});
```

Or on the `Form` object:

```js
Meli.Forms
    .init([])
    .then(() => {
        const formElement = document.getElementById('my-form');
        const form = new Meli.Forms.Form(form);
        form.addEventListener('submitted', () => {
            console.log('submitted');
        });
    })
    .catch(console.error);
```

| Event | Callback signature | Description |
|----|----|----|
| `submitting` | `() => void` | The form submit callback was called. |
| `submitted` | `() => void` | The form was submitted successfully. |
| `error` | `(error) => void` | Something went wrong. |

## Development

1. Run Meli locally
1. Ship a site with a form
1. Run `npx http-server -p 3030 .`
1. In your site's `index.html`, use `http://localhost:3030/build/browser.js` for the SDK src
1. Start the build `npm i && npm start`