open-index/open-npm huggingface dataset:
npm package: @syncfusion/ej2-angular-pipes
Description: A common package of Syncfusion Angular UI Components which contains pipes that help to achieve data operations.
Latest version: 29.2.9
Deprecated: false

# ej2-angular-pipes

A common package of Syncfusion Angular UI Components which contains pipes that help to achieve data operations.

This is a commercial product and requires a paid license for possession or use. Syncfusion’s licensed software, including this component, is subject to the terms and conditions of Syncfusion's EULA (https://www.syncfusion.com/eula/es/). To acquire a license, you can purchase one at https://www.syncfusion.com/sales/products or start a free 30-day trial here (https://www.syncfusion.com/account/manage-trials/start-trials).

A free community license (https://www.syncfusion.com/products/communitylicense) is also available for companies and individuals whose organizations have less than $1 million USD in annual gross revenue and five or fewer developers.

## Setup

To install `ej2-angular-pipes` and its dependent packages, use the following command

```
npm install @syncfusion/ej2-angular-pipes
```

## Usage

import the module `PipesModule` from the package `@syncfusion\ej2-angular-pipes`.

```
import { DeepWatch } from '@syncfusion/ej2-angular-pipes';
```

Add the imported module in your main module imports

```
import { DeepWatch } from '@syncfusion/ej2-angular-pipes';

@Component({
  standalone: true,
  imports: [DeepWatch]
})
export class AppComponent
```

We have provided the below pipes in this package.

* DeepWatch

### DeepWatch

This pipes helps to watch your data source and if any changes has been detected the this will be forwarded to mapped Syncfusion Angular UI Component. 

Arguments List
    - _componentRef_ - Reference of Syncfusion Angular UI Component
    - _propertyName_ - Name of the property the we used in.
    - _refreshOnChange_ - Refresh the whole control when the change has been detected

Syntax `ejsdeepwatch:<componentRef>:<propertyName string>:<optional refreshOnChange>'`

Example using,

```
<ejs-dropdownlist id='ele' #compRef [dataSource]='data | ejsdeepwatch:compRef:"dataSource":true'></ejs-dropdownlist>
```


### Supported Frameworks
The Essential JS 2 is also offered in following list of frameworks.

* JavaScript
* React
* Vue.js
* ASP.NET Core
* ASP.NET MVC

### Showcase Applications
* Diagram Builder
* Expense Tracker
* Loan Calculator
* Stock Chart
* Web Mail

## Support
Product support is available for through following mediums.

* Creating incident in Syncfusion Direct-trac support system or Community forum.
* New [GitHub issue](https://github.com/syncfusion/ej2-angular-ui-components/issues/new).
* Ask your query in Stack Overflow with tag syncfusion and ej2.

## License
Check the license detail [here](https://github.com/syncfusion/ej2-angular-ui-components/blob/master/license).
npm package: @syncfusion/figma-mcp-server
Description: Model Context Protocol server for Figma integration
Latest version: 0.2.0

# Figma MCP Server

Give **Syncfusion AI Continue** access to your Figma files with this [Model Context Protocol](https://modelcontextprotocol.io/introduction) server.

When Continue has access to Figma design data, it's **way** better at one-shotting designs accurately than alternative approaches like pasting screenshots.

## How it works

1. Open Continue chat window.
2. Paste a link to a Figma file, frame, or group.
3. Ask Continue to do something with the Figma file—e.g. implement a design.
4. Continue will fetch the relevant metadata from Figma and use it to write your code.

This MCP server is specifically designed for use with Continue. Before responding with context from the [Figma API](https://www.figma.com/developers/api), it simplifies and translates the response so only the most relevant layout and styling information is provided to the model.

Reducing the amount of context provided to the model helps make the AI more accurate and the responses more relevant.



### How to Generate the Build File (`dist/index.js`)

1. Navigate to the figma directory (src/figma) and run the following command in the VS Code terminal.

    `npm install`
3. Run the command `npm run build` to generate the build file.

## Configuration

Here's the configuration to use the Figma server in Syncfusion Code Studio:

```json
"experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "node",
          "args": [
            "PATH_TO_BUILD_Directory\\dist\\index.js",
            "--figma-api-key=FIGMA_API_KEY ",
            "--stdio"
          ],
          "env": {
            "FIGMA_API_KEY": "FIGMA_API_KEY"
          }
        }
      }
    ]
  }
```

- `FIGMA_API_KEY`: Follow [these instructions](https://help.figma.com/hc/en-us/articles/8085703771159-Manage-personal-access-tokens) on how to create a Figma API access token, then replace `FIGMA_API_KEY` with your token.

## Available Tools

The server provides the following MCP tools:

### get_figma_data

Fetches information about a Figma file.

Parameters:

- `fileKey` (string): The key of the Figma file to fetch
- `nodeId` (string): The ID of the node to fetch
- `depth` (number, optional): How many levels deep to traverse the node tree

### download_figma_images

Download SVG and PNG images used in a Figma file based on the IDs of image or icon nodes
npm package: @syncfusion/mongodb-mcp-server
Description: A Model Context Protocol server for MongoDB connections
Author: Syncfusion
Latest version: 0.2.0

# MCP MongoDB Server

A Model Context Protocol server that provides access to MongoDB databases. This server enables LLMs to inspect collection schemas and execute MongoDB operations.
## Features

### Resources
- List and access collections via `mongodb://` URIs
- Each collection has a name, description and schema
- JSON mime type for schema access

### Tools
- **query**
  - Execute MongoDB queries with optional execution plan analysis
  - Input: Collection name, filter, projection, limit, explain options
  - Returns query results or execution plan

- **aggregate**
  - Execute MongoDB aggregation pipelines with optional execution plan analysis
  - Input: Collection name, pipeline stages, explain options
  - Returns aggregation results or execution plan

- **update**
  - Update documents in a collection
  - Input: Collection name, filter, update operations, upsert/multi options
  - Returns update operation results

- **serverInfo**
  - Get MongoDB server information and status
  - Input: Optional debug info flag
  - Returns version, storage engine, and server details

- **insert**
  - Insert documents into a collection
  - Input: Collection name, documents array, write options
  - Returns insert operation results

- **createIndex**
  - Create indexes on a collection
  - Input: Collection name, index specifications, write options
  - Returns index creation results

- **count**
  - Count documents matching a query
  - Input: Collection name, query filter, count options
  - Returns document count

### Prompts
- `analyze_collection` - Analyze collection structure and contents
  - Input: Collection name
  - Output: Insights about schema, data types, and statistics


## Development

Install dependencies:
```bash
npm install
```

## Configuration  for Development

### Using Syncfusion Code Studio

To use with Syncfusion Code Studio, add the server config:


```json
{
  "experimental": {
  "modelContextProtocolServers": [
    {
      "transport": {
        "type": "stdio",
        "command": "node",
        "args": [
          "<path-to-mcp-mongo-server>/build/index.js",
          "mongodb://<username>:<password>@<cluster-url>/<databasename>?retryWrites=true&w=majority"
        ]
      }
    }
  ]
}
}
```
## Components


### Resources

The server provides schema information for each collection in the database:

- **Collection Schemas** (`mongodb://<host>/<collection>/schema`)
  - JSON schema information for each collection
  - Includes field names and data types
  - Automatically inferred from collection documents
npm package: @syncfusion/playwright-mcp-server
Description: Model Context Protocol servers for Playwright
Latest version: 0.1.0

# Playwright MCP Server

A Model Context Protocol server that provides browser automation capabilities using Playwright. This server enables LLMs to interact with web pages, take screenshots, and execute JavaScript in a real browser environment.

## How to Generate the Build File (`dist/index.js`)

### 1. Install Dependencies  
Navigate to the Playwright directory (src/playwright) and run the following command in the VS Code terminal.

```npm install```

### 2. Build the Code 
Run the following command to generate the build file:

```npm run build```


## [Documentation](https://executeautomation.github.io/mcp-playwright/) | [API reference](https://executeautomation.github.io/mcp-playwright/docs/playwright-web/Supported-Tools)


## Configuration to use Playwright Server
Here's theconfiguration to use the Playwright server in Syncfusion AI Continue:

```json
"experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "node",
          "args": [
            "PATH_TO_BUILD_Directory\\dist\\index.js"
          ]
        }
      }
    ]
  }
```
npm package: @syncfusion/sql-mcp-server
Description: Model Context Protocol Server project for SQL
Latest version: 0.1.0

# SQL Tool for MCP

This tool provides SQL functionality for the Model Context Protocol (MCP) server. It allows executing various SQL operations on a SQLite database.

## Features

- Execute SELECT queries
- Execute INSERT, UPDATE, or DELETE queries
- Create new tables
- List existing tables
- Describe table schema

## Setup

1. Ensure you have the necessary dependencies installed:
   - @modelcontextprotocol/sdk
   - sqlite3

2. Update the `PATH_TO_YOUR_DATABASE_FILE` in the `executeSQLiteQuery` function to point to your SQLite database file.

## Usage

The SQL tool exposes the following functions:

1. `read_query`: Execute a SELECT query on the SQLite database
2. `write_query`: Execute an INSERT, UPDATE, or DELETE query on the SQLite database
3. `create_table`: Create a new table in the SQLite database
4. `list_tables`: List all tables in the SQLite database
5. `describe_table`: Get the schema information for a specific table

Each function has its own input schema and error handling.

## Integration

This tool is designed to work with the MCP server. It sets up request handlers for listing tools and executing tool calls.

## Error Handling

Each function includes error handling to catch and report any issues that may occur during query execution.

## Security Note

Ensure proper input validation and sanitization when using this tool in a production environment to prevent SQL injection attacks.