open-index/open-npm huggingface dataset:
npm package: @kaia-team/n8n-nodes-kaia
Description: n8n node to interact with Kaia API for signal capture and security gating
Author: Kaia
Latest version: 0.5.15

# n8n-nodes-kaia

n8n community node package for interacting with the Kaia API.

## Nodes

### Save Signal

Capture a signal for knowledge graph processing. This node automatically populates workflow context fields and sends signals to the Kaia API.

**Features:**
- Auto-populates workflow context (workflowId, workflowName, executionId, nodeId, nodeName)
- Supports all signal types and optional fields
- Auto-generates SHA-256 content hash for deduplication
- Supports LLM context, knowledge graph, tags, and priority levels

### Security Gate

Check entity context from the knowledge graph and block workflow execution if conditions are not met.

**Features:**
- Evaluates entity facts and relations
- Supports multiple operators (equals, not equals, exists, not exists)
- Blocks workflow execution when conditions are not met
- Returns full context data when proceeding

### Model Gate

Intercept LLM input and output to record all interactions for AI Act compliance. This node can be placed after any LLM node to capture and log AI interactions.

**Features:**
- Captures LLM prompts, responses, and metadata
- Extracts tool calls and decisions from AI responses
- Records token usage and latency metrics
- Sends separate input and output signals to Kaia API
- Non-blocking: workflow continues even if signal sending fails
- Includes signal status in output for debugging (`_kaiaSignalStatus`)

**Usage:**
1. Place the Model Gate node after an LLM node (e.g., OpenAI, Anthropic, etc.)
2. Configure Kaia API credentials
3. The node will automatically capture input/output and send compliance signals

**Compatibility:**
- Tested with n8n v1.x+
- Works with all LangChain-compatible LLM nodes

## Credentials

### Kaia API

Bearer token authentication with base URL configuration.

**Required Fields:**
- Base URL: The base URL of the Kaia API
- Bearer Token: Authentication token

## Installation

```bash
npm install n8n-nodes-kaia
```

## Development

```bash
# Install dependencies
npm install

# Build the package
npm run build

# Run linter
npm run lint

# Format code
npm run format
```

## License

MIT
npm package: @kaiachain/contracts
Description: Secure Smart Contract library for Solidity
Author: Kaia Community
Latest version: 1.0.1

# Kaia Contracts

[![Docs](https://img.shields.io/badge/docs-%F0%9F%93%84-blue)](https://docs.kaia.io)
[![NPM Package](https://badge.fury.io/js/@kaiachain%2Fcontracts.svg)](https://www.npmjs.com/package/@kaiachain/contracts)
[![Gitter](https://badges.gitter.im/kaiachain/kaia-contracts.svg)](https://gitter.im/kaiachain/kaia-contracts?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

**A library for secure smart contract development.** Build on a solid foundation of community-vetted code.
It is a fork of openzepplin contracts. In addition to that, this repository contains Kaia's token standards such as KIP-7, KIP-17, and KIP-37 compatible with ERC-20, ERC-721, and ERC-1155 respectively.

Please refer to [this](https://kips.kaia.io/token) link for the mapping of Ethereum to Kaia token standards.

## Overview

### Installation

```console
$ npm install @kaiachain/contracts
```

An alternative to npm is to use the GitHub repository `kaiachain/kaia-contracts` to retrieve the contracts. When doing this, make sure to specify the tag for a release such as `v1.0.0`, instead of using the `main` branch.

### Usage

Once installed, you can use the contracts in the library by importing them:

```solidity
pragma solidity ^0.8.0;

import "@kaiachain/contracts/KIP/token/KIP17/KIP17.sol";

contract MyCollectible is KIP17 {
    constructor() KIP17("MyCollectible", "MCO") {
    }
}
```

To keep your system secure, you should **always** use the installed code as-is, and neither copy-paste it from online sources, nor modify it yourself. The library is designed so that only the contracts and functions you use are deployed, so you don't need to worry about it needlessly increasing gas costs.

## Contribute

In line with our commitment to decentralization, all Kaia codebase and its documentations are completely open source. Kaia always welcomes your contribution. Anyone can view, edit, fix its contents and make suggestions. You can either create a pull request on GitHub or use GitBook. Make sure to sign our Contributor License Agreement (CLA) first and there are also a few guidelines our contributors would check out before contributing:

- [Contribution Guide](./CONTRIBUTING.md)
- [License](./LICENSE)
- [Code of Conducts](./code-of-conduct.md)

## Need Help? <a href="#need-help" id="need-help"></a>

If you have any questions, please visit our [Gitter channel](https://gitter.im/kaiachain/kaia-contracts?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge), [Kaia Developers Forum](https://forum.kaia.io/) and [Discord channel](https://discord.gg/kaiachain).

## License

 Contracts is released under the [MIT License](LICENSE).

## Acknowledgments 

Thanks for Openzepplin Team for providing the  contracts.
npm package: @kaiachain/js-ext-core
Description: Sub-components of Kaia JavaScript SDKs.
Latest version: 2.1.0

# JavaScript Extension Core for Kaia

Sub-components of Kaia JavaScript SDKs.

> **_NOTE:_**
> @kaiachain/js-ext-core@^1.2.0 recommends node 22 or later if you have issues with ES Module resolution.

For dApp developers and blockchain users, use the SDKs like [@kaiachain/ethers-ext](https://www.npmjs.com/package/@kaiachain/ethers-ext) and [@kaiachain/web3js-ext](https://www.npmjs.com/package/@kaiachain/web3js-ext).

- `FieldSetFactory` to easily build custom RLP-encodable types
- `AccountKeyFactory` for Kaia account objects
- `KlaytnTxFactory` for Kaia transaction objects
- `AccountKeyType` and `TxType` enums
- `getRpcTxObject` to normalize `eth_call` RPC parameters
- `getCompressedPublicKey` and `getSignatureTuple` to normalize cryptographic data
- `splitKeystoreKIP3` for handling KIP-3 JSON keystore
- `formatKaia` and `parseKaia` to convert KAIA denominations
- `asyncOpenApi` to promisify [@kaiachain/web3rpc](https://www.npmjs.com/package/@kaiachain/web3rpc) methods

## Install

```
npm install --save @kaiachain/js-ext-core
```

## Usage

See test.
npm package: @kaiachain/kss-cli
Description: kaia service sdk command line
Author: Kaia Community
Latest version: 1.0.0

# Kaia Service SDK CLI

kss-cli is a command line utility for kaia service sdk. <br/>
kss-cli supports below features.
* `Oracles` - Hardhat project containing Witnet integrations with kaia.

## Install

```typescript
npm install -g @kaiachain/kss-cli --force
```

## Quick Usage

### Version

```bash
> kss-cli --version 
0.0.1
```

### Help

```typescript
> kss-cli --help
> kss-cli help oracle
```
### Setup

#### Oracles

To download the Kaia's integration with witnet oracle hardhat project, please follow below steps

```typescript
> kss-cli oracle init

> cd oracle-starter-kit
> npm install --force
```

Above command downloads the `oracle-starter-kit` hardhat folder structure in the current project directory. 
Enter inside the generated folder and install the packages as mentioned and please follow the `oracle-starter-kit` README description.
npm package: @kaiachain/kss-dexs
Description: Includes open-dex-contracts integration & use-cases
Author: Kaia Community
Latest version: 1.0.1

# DEX Starter Kit
This module includes the integration of [@kaiachain/open-dex-contracts](https://github.com/kaiachain/open-dex-contracts).

# How to setup locally
 `npm install`

# Overview
For details information & documentation of each module of this package please refer to the docs linked below.
- #### [Folder Structure of the package](https://github.com/kaiachain/kaia-service-sdk/blob/main/packages/dexs-starter-kit/docs/FolderStructure.md)
- #### [Prerequisites](https://github.com/kaiachain/kaia-service-sdk/blob/main/packages/dexs-starter-kit/docs/Prerequisites.md)
- #### [How To use](https://github.com/kaiachain/kaia-service-sdk/blob/main/packages/dexs-starter-kit/docs/HowToUse.md)
npm package: @kaiachain/viem-ext
Description: viem extension for kaia blockchain
Latest version: 2.1.0

# Viem Extension for Kaia

Viem Extension for Kaia offers:

- Supports both Ethereum and kaia transaction types.
- Work with both MetaMask (`window.ethereum`) and Kaikas (`window.klaytn`)

## Install

> **_NOTE:_**
> @kaiachain/viem-ext@^2.0.5 and above recommends node 20 or later if you have issues with ES Module resolution.

### Node.js

- Install
    ```sh
    npm install --save @kaiachain/viem-ext
    ```
- ESM or TypeScript
    ```ts
    import { http, createPublicClient, kairos } from "@kaiachain/viem-ext";
    const publicClient = createPublicClient({
        chain: kairos,
        transport: http(),
    })
    ```
- CommonJS
    ```js
    const { http, createPublicClient, kairos } = require("@kaiachain/viem-ext");
    const publicClient = createPublicClient({
        chain: kairos,
        transport: http(),
    })

## Usage

See [example](./examples) and [test](./tests).
npm package: @kaiachain/web3js-ext
Description: web3.js extension for kaiachain blockchain
Latest version: 2.1.0

# Web3.js Extension for kaia

Web3.js Extension for kaia offers:

- Drop-in replacement to `new Web3(...)` that supports both Ethereum and kaia transaction types involving AccountKey and TxTypes. See [Modifications to the Web3 object](#modifications-to-the-web3-object) section for details

## Install

> **_NOTE:_**
> @kaiachain/web3js-ext@^1.2.0 recommends node 22 or later if you have issues with ES Module resolution.

### Node.js

- Install
    ```sh
    npm install --save @kaiachain/web3js-ext
    ```
- ESM or TypeScript
    ```ts
    import { Web3 } from "@kaiachain/web3js-ext";
    const web3 = new Web3("https://public-en-kairos.node.kaia.io");
    ```
- CommonJS
    ```js
    const { Web3 } = require("@kaiachain/web3js-ext");
    const web3 = new Web3("https://public-en-kairos.node.kaia.io");
    ```

### Browser

It is not recommended to use CDNs in production, But you can use below for quick prototyping.

```html
<script src="https://cdn.jsdelivr.net/npm/@kaiachain/web3js-ext@latest/dist/web3js-ext.bundle.js"></script>
<script>
const web3 = new web3_ext.Web3(window.klaytn);
</script>
```

## Usage

See [example](./example) and [test](./test).

## Modifications to the Web3 object

See [DESIGN](./DESIGN.md) for source code organization.

### Accounts

- Following functions can handle Klaytn TxTypes. See [src/account/index.ts](./src/account/index.ts)
  ```js
  // account independent functions
  web3.eth.accounts.recoverTransaction(rlp)
  web3.eth.accounts.signTransaction(obj or rlp)
  web3.eth.accounts.signTransactionAsFeePayer(obj or rlp)

  // account-bound functions
  var account = web3.eth.accounts.create()
  var account = web3.eth.accounts.privateKeyToAccount(priv)
  var account = web3.eth.accounts.decrypt(keystore)
  account.signTransaction(obj or rlp)
  account.signTransactionAsFeePayer(obj or rlp)
  ```
- Following functions can handle the [KIP-3 Klaytn keystore format v4](https://kips.kaia.io/KIPs/kip-3)
  ```js
  web3.eth.accounts.decrypt(keystore)
  web3.eth.accounts.decryptList(keystore)
  ```

### Eth RPC wrappers

- Following functions calls different RPC, and handle Klaytn TxTypes. See [src/eth/index.ts](./src/eth/index.ts)
  ```js
  // Try klay_protocolVersion, falls back to eth_protocolVersion
  web3.eth.getProtocolVersion()

  // klay_sendTransaction if Klaytn TxType, otherwise eth_sendTransaction
  // Additional treatment for Kaikas compatibility
  web3.eth.sendTransaction(obj)

  // klay_sendRawTransaction if Klaytn TxType, otherwise eth_sendRawTransaction
  web3.eth.sendSignedTransaction(rlp)

  // klay_signTransaction if Klaytn TxType, otherwise eth_signTransaction
  // Additional treatment for Kaikas compatibility
  web3.eth.signTransaction(obj)
  ```

### Klaytn RPCs

- Following functions calls Klaytn RPCs. See [src/web3.ts](./src/web3.ts)
  ```js
  web3.klay.blockNumber() // klay_blockNumber
  web3.net.networkID() // net_networkID
  ```
npm package: @kaiaf/logger
Description: A very simple logger
Author: Iris
Latest version: 1.1.0

# NodeJS Logger

Just a simple logger.

```bash
[{namespace} - {filename}:{line number}:{line number}] (Info) This is a simple logger!
```

Usage:

```js
const Logger = require('@kaiaf/logger').create('namespace');
Logger.setLevel(USE_DEBUG === 'true' ? 'debug' : 'info');
Logger.debug('This is debug');
Logger.debugOr('This message will display if debug is enabled', 'This message will display if it\'s not');
Logger.info('Hi there');
Logger.warn('This is warn');
Logger.error('This is error');
```
npm package: @kaiaf/skinview-utils
Description: Utilities for working with Minecraft skins
Author: Haowei Wen
Latest version: 0.6.7

skinview-utils
========

[![CI Status](https://img.shields.io/github/workflow/status/bs-community/skinview-utils/CI?label=CI&logo=github&style=flat-square)](https://github.com/bs-community/skinview-utils/actions?query=workflow:CI)
[![NPM Package](https://img.shields.io/npm/v/skinview-utils.svg?style=flat-square)](https://www.npmjs.com/package/skinview-utils)
[![MIT License](https://img.shields.io/badge/license-MIT-yellowgreen.svg?style=flat-square)](https://github.com/bs-community/skinview-utils/blob/master/LICENSE)
[![Gitter Chat](https://img.shields.io/gitter/room/TechnologyAdvice/Stardust.svg?style=flat-square)](https://gitter.im/skinview3d/Lobby)

Utilities for working with Minecraft skins
npm package: @kaiarajs/web-app
Description: This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).
Latest version: 0.0.4

This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).

## Getting Started

First, run the development server:

```bash
npm run dev
# or
yarn dev
```

Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.

You can start editing the page by modifying `pages/index.tsx`. The page auto-updates as you edit the file.

[API routes](https://nextjs.org/docs/api-routes/introduction) can be accessed on [http://localhost:3000/api/hello](http://localhost:3000/api/hello). This endpoint can be edited in `pages/api/hello.ts`.

The `pages/api` directory is mapped to `/api/*`. Files in this directory are treated as [API routes](https://nextjs.org/docs/api-routes/introduction) instead of React pages.

## Learn More

To learn more about Next.js, take a look at the following resources:

- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.

You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome!

## Deploy on Vercel

The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.

Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details.
npm package: @kaiban/tools
Description: A set of tools to work with LLMs and KaibanJS
Author: Kaiban Team
Latest version: 0.0.1

# Kaiban Tools for AI Agents

This package provides a collection of specialized tools designed for use with AI agents, enhancing their capabilities for various tasks.

## Purpose

The Kaiban Tools package offers a set of tools that can be integrated into AI agent systems, allowing agents to perform a wide range of tasks more effectively. These tools are designed to extend the capabilities of AI agents, enabling them to interact with external services, process data, and perform complex operations.

## Features

- A collection of tools specifically designed for AI agents
- Easy integration with existing agent frameworks and architectures
- Tools for various purposes, including web scraping, data transformation, and more
- Configurable options for each tool to suit different agent requirements

## Installation

```bash
npm install @kaiban/tools
```

## Available Tools

### 1. Firecrawl
Firecrawl is a tool that allows agents to interact with the Firecrawl web scraping service, enabling them to extract clean, structured data from websites.

Learn more: https://www.firecrawl.dev/

### 2. Tavily Search
Tavily Search is a tool that provides AI-optimized search capabilities, delivering comprehensive and accurate results. It's particularly useful for retrieving current information and answering questions about recent events.

Learn more: https://tavily.com/

## Development

### Local Setup

1. Install dependencies:
```bash
npm install
```

2. Build the package:
```bash
npm run build
```

3. Run Storybook to view and test components:
```bash
npm run storybook
```

4. Run tests:
```bash
npm run test
```

### Environment Variables

Create a `.env` file in the root directory with your API keys:
```env
VITE_FIRECRAWL_API_KEY=your_firecrawl_api_key
VITE_TAVILY_API_KEY=your_tavily_api_key
```

## Contributing

[Information about how to contribute to the package]

## License

MIT License
npm package: @kaibu/korg-nano-kontrol
Description: Node.js/Browser library for KORG nanoKONTROL and nanoKONTROL2
Author: Sho Hashimoto
Latest version: 0.2.10

# korg-nano-kontrol
Node.js/Browser library for KORG [nanoKONTROL](http://www.amazon.co.jp/dp/B001H2P294/shokai-22) and [nanoKONTROL2](http://www.amazon.co.jp/dp/B004M8UZS8/shokai-22).

- https://github.com/shokai/korg-nano-kontrol
- https://npmjs.com/package/korg-nano-kontrol

[![Circle CI](https://circleci.com/gh/shokai/korg-nano-kontrol.svg?style=svg)](https://circleci.com/gh/shokai/korg-nano-kontrol)


## Install

    % npm install korg-nano-kontrol -save

- On Node.js, This library depends on [midi npm](https://www.npmjs.com/package/midi) to handle MIDI messages. Please install ALSA libs after run npm install.
- On Browser, require [WebMIDI API](http://www.w3.org/TR/webmidi/) support.

## Samples
- [Node.js](https://github.com/shokai/korg-nano-kontrol/tree/master/samples/node)
- [WebMIDI](https://github.com/shokai/korg-nano-kontrol/tree/master/samples/webmidi)
- [Hue controller](https://github.com/shokai/hue-korg-control)

## Usage

### Connect

find `nanoKONTROL` or `nanoKONTROL2`
```javascript
var nanoKONTROL = require('korg-nano-kontrol');

nanoKONTROL.connect()
.then(function(device){
  console.log('connected!' + device.name);
  // do something
})
.catch(function(err){
  console.error(err);
});
```

specify device name
```javascript
nanoKONTROL.connect('nanoKONTROL2').then( function(device){ } );
```

### Register Events

```javascript
// register specific slider/knob/button events
device.on('slider:0', function(value){
  console.log("slider:0 >>> "+value);
});

device.on('knob:1', function(value){
  console.log("knob:1 >>> "+value);
});

device.on('button:play', function(value){
  console.log("button:play >>> "+value);
});


// catch all slider/knob/button events
device.on('slider:*', function(value){
  console.log(this.event+' => '+value);
});

device.on('knob:*', function(value){
  console.log(this.event+' => '+value);
});

device.on('button:**', function(value){
  console.log(this.event+' => '+value);
});
```

### Close
```javascript
device.close();
```

### Scene
nanoKONTROL has a `scene` button

```javascript
console.log(device.scene); // => return 1~4

device.on('button:scene', function(scene){
  console.log(scene);
});
```

## Debug

enable [debug npm](https://www.npmjs.com/package/debug)

for node.js

    % export DEBUG="korg-nano-kontrol:*"

for browser

    localStorage.debug = "korg-nano-kontrol:*";

## Build

    % npm run build
    % npm run buildSample

    % npm run watch

## Test

    % npm install

    % npm test
    # or
    % npm run watch