open-index/open-npm huggingface dataset:
npm package: @kerryback/data-portal-mcp
Description: MCP server for Rice Business Stock Market Data Portal - Access financial data through Claude Desktop
Author: Kerry Back
Latest version: 1.0.0

# Rice Stock Data MCP Server

A Model Context Protocol (MCP) server for accessing Rice Business Stock Market Data Portal through Claude Desktop.

## Features

- Natural language queries for stock market data
- Access to comprehensive financial metrics and indicators
- Rice University email verification for access control
- Seamless integration with Claude Desktop

## Claude Desktop Configuration

### Step 1: Get Your Access Token
1. Visit the Rice Business Stock Market Data Portal
2. Verify your Rice University email address
3. Copy your personal access token

### Step 2: Configure Claude Desktop
1. Open Claude Desktop
2. Go to Settings → Developer → Edit Config
3. Add the following configuration to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "rice-stock-data": {
      "command": "npx",
      "args": ["@kerryback/data-portal-mcp"],
      "env": {
        "USER_ACCESS_TOKEN": "YOUR_ACCESS_TOKEN_HERE",
        "APP_URL": "https://data-portal-mcp.rice-business.org"
      }
    }
  }
}
```

4. Replace `YOUR_ACCESS_TOKEN_HERE` with your actual access token from Step 1
5. Save the configuration file
6. Restart Claude Desktop

### Step 3: Using the MCP Server
Once configured, you can ask Claude questions about stock market data:
- "Show me tech stocks with PE under 20"
- "What are Apple's financial ratios?"
- "List healthcare companies by market cap"
- "Get the latest earnings data for Microsoft"
- "Compare revenue growth across FAANG stocks"

## Local Development

### Installation
```bash
npm install
npm run build
```

### Running the MCP Server Locally
```bash
npm run start:mcp
```

### Running the Web Server (for deployment)
```bash
npm start
```

## Environment Variables

- `USER_ACCESS_TOKEN` - Your personal Rice Data Portal access token (required)
- `APP_URL` - Data portal base URL (default: https://data-portal-mcp.rice-business.org)
- `PORT` - Web server port (default: 8000, used for deployment only)

## API Endpoints

The web server provides these endpoints (for deployment):
- `GET /` - Server information
- `GET /health` - Health check endpoint
- `POST /chat` - Query endpoint (requires token in request body)

## Troubleshooting

### "Authentication failed" error
- Verify your access token is correct and hasn't expired
- Ensure you've verified your Rice University email

### "Rate limit exceeded" error
- Wait a moment before making additional queries
- The API has rate limiting to ensure fair usage

### Claude Desktop doesn't show the MCP server
- Make sure you've restarted Claude Desktop after configuration
- Check that the configuration JSON is valid (no syntax errors)
- Verify the package name is correct: `@kerryback/data-portal-mcp`

## Support

For issues or questions about:
- **MCP Server**: Open an issue in this repository
- **Data Portal Access**: Contact Rice Business IT support
- **Stock Data**: Refer to the Rice Business Stock Market Data Portal documentation

## License

MIT
npm package: @kersvers/eslint-config
Description: Generic base configuration for [ESLint][eslint] supporting setups using [TypeScript][typescript] and [React][react].
Latest version: 2.0.2

# Kersvers ESLint Configuration
Generic base configuration for [ESLint][eslint] supporting setups using
[TypeScript][typescript] and [React][react].


## Available configurations
The following configurations are available and can be extended in a
project-specific ESLint configuration. Note that it's possible to mix and match
configurations.

- [`@kersvers/eslint-config`](./index.js)  
  Base configuration for TypeScript projects.
- [`@kersvers/eslint-config/react`](./react.js)  
  Additional configuration and rules for projects using [React][react] and JSX
  targeting browser environments.


## Usage
### Installation
Create a `.npmrc` file in the root of your project to point the npm CLI to GitHub Packages as the npm registry:

```shell
@kersvers:registry=https://npm.pkg.github.com/kersvers
```

Install the package using the following command. You need to be [authenticated to GitHub Packages](https://docs.github.com/en/packages/guides/configuring-npm-for-use-with-github-packages#authenticating-to-github-packages):

```shell
$ npm install @kersvers/eslint-config --save-dev
```

ESLint plugins used by this config must also be installed within your project. This is a [limitation within ESLint](https://github.com/eslint/rfcs/pull/5).

```shell
$ npx install-peerdeps --dev @kersvers/eslint-config
```

### Extending
Use the [`extends`][eslint-extends] feature provided by ESLint in the
project-specific `.eslintrc` configuration file.

```json
{
    "extends": [
        "@kersvers/eslint-config",
        "@kersvers/eslint-config/react"
    ]
}
```

### Scripts
The following scripts can be added to `package.json` to make it easier to start
the linter.

```json
{
    "scripts": {
        "lint:js": "eslint \"src/**/*.{ts,tsx}\" \"*.js\"",
        "lint:fix": "npm run lint:js -- --fix"
    }
}
```



[eslint]: https://eslint.org/
[react]: https://reactjs.org/
[typescript]: https://www.typescriptlang.org/
[eslint-extends]: https://eslint.org/docs/user-guide/configuring#extending-configuration-files
npm package: @kerthin/microservice
Description: kerthin microservice
Author: thekerthin@gmail.com
Latest version: 0.0.1-alpha.7

# `@kerthin/microservice`

This package helps you building decouple systems where the projects can scale up from a monolith system to microservice system without any troubles just changing a couple code lines.

## Installation

```sh
$ yarn add @kerthin/microservice
# or
$ npm i @kerthin/microservice
```

## Usage

_**Note:** So far this package is only available for [nest.js](https://nestjs.com/) framework but in the future we'll support different frameworks and programing languages_

### Create DTO

```ts
import { TransferDataDto } from '@kerthin/microservice';

class CreateUserDto extends TransferDataDto {

  name: string;

  lastName: string;

  birthday: Date;

  ...
}
```


### Create Command

```ts
import { Command } from '@kerthin/microservice';

class CreateUserDto extends Command<CreateUserDto> {

  public readonly action = 'create';

  public readonly context = 'user';

}
```

### Create Service

```ts
import { Injectable } from '@nestjs/common';
import { Broker } from '@kerthin/microservice';

@Injectable()
export class UserService {

  constructor(private readonly broker: Broker) {}

  create(data: CreateUserDto) {
    return this.broker
      .start()
      .add(new CreateUserDto(data))
      .end();
  }

}
```

### Create Command Handle

```ts
import { CommandHandler, ICommandHandler } from '@kerthin/microservice';

@CommandHandler(CreateUserCommand)
export class CreateUserHandler implements ICommandHandler<CreateUserCommand> {

  handle(command: CreateUserCommand) {
    // command.data -> compute your logic
  }

}
```
npm package: @kerunix/nuxt-init
Description: CLI tool to scaffold a Nuxt application with opinionated defaults
Latest version: 1.2.0

# nuxt-init

A CLI tool to scaffold a Nuxt application with opinionated defaults including:

- ✨ ESLint with Anthony Fu's config
- 🎨 Tailwind CSS with Vite plugin
- 🧩 Shadcn/vue components
- 🎬 Motion-v animations
- 📁 App directory structure (Nuxt 4 default)
- 📦 pnpm

## Usage

```bash
pnpm dlx @kerunix/nuxt-init my-app

## What it does

1. Scaffolds a new Nuxt 3 project
2. Installs and configures ESLint with @antfu/eslint-config
3. Sets up Tailwind CSS with proper configuration
4. Installs and configures Shadcn/vue with correct paths
5. Adds Motion-v for animations

## Requirements

- Node.js 18+
- pnpm, npm, or yarn

## License

MIT
npm package: @keruru-amuri/task-master
Description: Task-Master MCP - Project Planning and Task Management System for Augment Code
Author: keruru-amuri
Latest version: 0.1.2

# Task-Master MCP

Task-Master MCP is a Master Control Program for Augment Code that provides project planning and task management capabilities. It generates and manages project plans in a standardized format (TASK.mdc), tracks task progress, and helps resume work on projects efficiently.

## Installation

```bash
# Install globally
npm install -g @keruru-amuri/task-master

# Or run directly with npx
npx -y @keruru-amuri/task-master
```

## Usage

### Command Line Interface

Task-Master MCP provides a command-line interface for managing projects:

```bash
# Start the MCP server
task-master start

# Initialize a new project
task-master init --name "My Project" --description "A description of my project"

# Initialize a project from a requirements file
task-master init --requirements requirements.txt

# Mark a task as completed
task-master complete "Setup project structure"

# Get project status
task-master status
```

### API Server

Task-Master MCP also provides an API server that can be used by Augment Code:

```bash
# Start the API server
task-master start --port 3000
```

The API server provides the following endpoints:

- `POST /api/projects` - Initialize a new project
- `POST /api/tasks/complete` - Mark a task as completed
- `GET /api/projects/status` - Get project status
- `GET /api/projects/resume` - Resume a project

### Integration with Augment Code

To integrate Task-Master MCP with Augment Code, add it to your MCP list in the settings:

```
npx -y @keruru-amuri/task-master
```

## Features

- **Project Initialization**: Automatically generate a structured project plan based on requirements
- **Task Management**: Track task status, add new tasks, and update existing ones
- **Progress Tracking**: Monitor project progress and task completion
- **Project Resumption**: Easily resume work on a project by identifying the next tasks to tackle
- **Markdown-based**: Uses a simple TASK.mdc file format that's both human and machine-readable

## TASK.mdc File Format

The TASK.mdc file uses a simple markdown format:

```markdown
# Project Name - Project Plan

## Project Overview
Project description goes here

## Environment Setup
```bash
# Setup instructions
```

## Implementation Tasks

### HIGH Priority Tasks
- [ ] Task 1
  - Description of task 1
  - [ ] Subtask 1.1
  - [ ] Subtask 1.2

### MEDIUM Priority Tasks
- [ ] Task 2
  - Description of task 2

### LOW Priority Tasks
- [ ] Task 3
  - Description of task 3

## Progress Tracking
- Started: 2023-01-01 12:00:00
- Last Updated: 2023-01-02 15:30:00
- Status: IN PROGRESS

## Next Steps
- Next step 1
- Next step 2

## Notes
Additional notes go here
```

## License

MIT
npm package: @keryanne/user-form
Description: This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.2.2.
Author: keryanne
Latest version: 1.0.1

# UserForm

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.2.2.

## Development server

Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any of the source files.

## Code scaffolding

Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.

## Build

Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory.

## Running unit tests

Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).

## Running end-to-end tests

Run `ng e2e` to execute the end-to-end tests via a platform of your choice. To use this command, you need to first add a package that implements end-to-end testing capabilities.

## Further help

To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.
npm package: @keshan3262/tezos-kms
Description: A fork of @tacoinfra/tezos-kms with performance improvements
Author: Blockscale LLC
Latest version: 1.1.4

# Tezos KMS

## About

`tezos-kms` is a typescript library which provides functionality for using keys stored in [AWS KMS](https://aws.amazon.com/kms/) for operations in [Tezos](https://tezos.com/).

## Configuration

In order to use keys you will need to configure a key in AWS KMS. Steps 1-12 of the [Harbinger Setup Guide](https://github.com/tacoinfra/harbinger-signer#setup-instructions) provide a brief overview of how to achieve this.

## Usage

```js
import { TezosKmsClient } from '@tacoinfra/tezos-kms'

const awsKeyId = 'x' // Place your key here.
const awsRegion = 'eu-west-1'

const kmsClient = new TezosKmsClient(awsKeyId, awsRegion)

console.log(await kmsClient.getPublicKey()) // sppk...
console.log(await kmsClient.getPublicKeyHash()) // tz2...

const bytes = Buffer.from('deadbeef', 'hex')
console.log(await kmsClient.signOperation(bytes)) // <bytes>
console.log(await kmsClient.signOperationBase58(bytes)) // spsig...
```

## Integration with Taquito

An example is given in [tests](src/tezos-kms-client.spec.ts). However, `TezosKmsSigner` may be exported by this module in the future.

## Building the Library

```shell
$ npm i
$ npm run build
```

## Testing

Correct tests with, particularly, mocks for responses from AWS are a TODO. Tests can be launched now following these steps:

1. Create a .env file and add these variables:
   - `KMS_KEY_ID` - id of KMS key.
   - `AWS_REGION` - AWS region to use for getting the key.
   - `SEND_TEZ_DESTINATION` - destination of test transfer of 1 mutez.
   - `RPC_URL` - URL of RPC for the network where transfer should be made.
   - `AWS_ACCESS_KEY_ID` - access key ID of AWS account
   - `AWS_SECRET_ACCESS_KEY` - secret access key of AWS account
2. Get PKH of the account which corresponds to your KMS key using this command: `npm run get-kms-pkh <kms-key-id> <aws-region>`
3. If the balance of account is too low to pay for transfer of 1 mutez, transfer some TEZ to the account to enable it to pay.
4. Run tests with command `npm run test`

## Credits

Harbinger is written and maintained by [Luke Youngblood](https://github.com/lyoungblood) and [Keefer Taylor](https://github.com/keefertaylor).
npm package: @keshan3262/use-wallet
Description: This is a fork of [aragon/use-wallet](https://github.com/aragon/use-wallet) with the same interface but it works with Klaytn and other EVM-compatible chains which are unknown to the original module.
Author: Inokentii Mazhara
Latest version: 0.13.5

# 👛 useWallet()

This is a fork of [aragon/use-wallet](https://github.com/aragon/use-wallet) with the same interface but it works with Klaytn and other EVM-compatible chains which are unknown to the original module.
npm package: @keshav-k3/webhook-mcp
Description: Webhook MCP server built with Bun
Latest version: 0.1.0

# webhook-mcp

A Bun-based MCP server that exposes two tools for sending POST requests to a configured webhook URL.

## Installation

```bash
npm install @keshav-k3/webhook-mcp
```

## Configuration

The server automatically detects the webhook service from the URL, or you can explicitly set `WEBHOOK_SERVICE`:

| Service | Format | Example Payload |
|---------|--------|----------------|
| **Discord** | `content` field | `{ "content": "Hello", "username": "Bot" }` |
| **Teams** | Adaptive Card | `{ "type": "message", "attachments": [{ "contentType": "application/vnd.microsoft.card.adaptive", "content": { "type": "AdaptiveCard", "body": [{ "type": "TextBlock", "text": "Hello" }] } }] }` |
| **Slack** | `text` field | `{ "text": "Hello" }` |
| **Telegram** | `text` field | `{ "text": "Hello" }` |
| **Generic** | `text` field | `{ "text": "Hello", "username": "Bot" }` |

### MCP Configuration

**Discord:**
```json
{
  "mcpServers": {
    "webhook-discord": {
      "command": "bun",
      "args": ["-y", "@keshav-k3/webhook-mcp"],
      "env": {
        "WEBHOOK_URL": "https://discord.com/api/webhooks/YOUR_WEBHOOK_ID/YOUR_WEBHOOK_TOKEN"
      }
    }
  }
}
```

**Teams (Power Automate):**
```json
{
  "mcpServers": {
    "webhook-teams": {
      "command": "bun",
      "args": ["-y", "@keshav-k3/webhook-mcp"],
      "env": {
        "WEBHOOK_URL": "https://...powerplatform.com/.../workflows/.../triggers/manual/paths/invoke?..."
      }
    }
  }
}
```

**Slack / Telegram / Generic:**
```json
{
  "mcpServers": {
    "webhook-slack": {
      "command": "bun",
      "args": ["-y", "@keshav-k3/webhook-mcp"],
      "env": {
        "WEBHOOK_URL": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
      }
    }
  }
}
```

## Tools

### `send_message`

Send a text message to the configured webhook endpoint. The message format adapts based on the detected service.

**Parameters:**
- `content` (string, required): Message content to send
- `username` (string, optional): Display name (supported by Discord and generic webhooks)
- `avatar_url` (string, optional): Avatar URL (supported by Discord and generic webhooks)

### `send_json`

Send an arbitrary JSON object to the configured webhook endpoint. Use this for full control over the payload format.

**Parameters:**
- `body` (object, required): JSON object to POST

## License

MIT