open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/mcp-qase
Description: MCP server implementation for Qase API
Latest version: 0.1.0

# QASE MCP Server

MCP server implementation for Qase API

This is a TypeScript-based MCP server that provides integration with the Qase test management platform. It implements core MCP concepts by providing tools for interacting with various Qase entities.

## Features

### Tools
The server provides tools for interacting with the Qase API, allowing you to manage the following entities:

#### Projects
- `list_projects` - Get all projects
- `get_project` - Get project by code
- `create_project` - Create new project
- `delete_project` - Delete project by code

#### Test Cases
- `get_cases` - Get all test cases in a project
- `get_case` - Get a specific test case
- `create_case` - Create a new test case
- `update_case` - Update an existing test case

#### Test Runs
- `get_runs` - Get all test runs in a project
- `get_run` - Get a specific test run

#### Test Results
- `get_results` - Get all test run results for a project
- `get_result` - Get test run result by code and hash
- `create_result` - Create test run result
- `create_result_bulk` - Create multiple test run results in bulk
- `update_result` - Update an existing test run result

#### Test Plans
- `get_plans` - Get all test plans in a project
- `get_plan` - Get a specific test plan
- `create_plan` - Create a new test plan
- `update_plan` - Update an existing test plan
- `delete_plan` - Delete a test plan

#### Test Suites
- `get_suites` - Get all test suites in a project
- `get_suite` - Get a specific test suite
- `create_suite` - Create a new test suite
- `update_suite` - Update an existing test suite
- `delete_suite` - Delete a test suite

#### Shared Steps
- `get_shared_steps` - Get all shared steps in a project
- `get_shared_step` - Get a specific shared step
- `create_shared_step` - Create a new shared step
- `update_shared_step` - Update an existing shared step
- `delete_shared_step` - Delete a shared step

## Development

Install dependencies:
```bash
npm install
```

Build the server:
```bash
npm run build
```

For development with auto-rebuild:
```bash
npm run watch
```

## Installation

### Claude Desktop

To use with Claude Desktop, add the server config:

- On MacOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
- On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

```json
{
  "mcpServers": {
    "mcp-qase": {
      "command": "/path/to/mcp-qase/build/index.js",
      "env": {
        "QASE_API_TOKEN": "<YOUR_TOKEN>"
      }
    }
  }
}
```

### Cursor

To use with Cursor, register the command as follows:

```
env QASE_API_TOKEN=<YOUR_TOKEN> /path/to/mcp-qase/build/index.js
```

## Debugging

Since MCP servers communicate over stdio, debugging can be challenging. We recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector):

```bash
npx -y @modelcontextprotocol/inspector -e QASE_API_TOKEN=<YOUR_TOKEN> ./build/index.js
```
npm package: @iflow-mcp/mcp-quick-sqlite3
Description: MCP server for SQLite database operations
Latest version: 1.0.0

# SQLite MCP Server

A Model Context Protocol (MCP) server that provides tools for querying SQLite databases. This server allows AI assistants to interact with SQLite databases by listing tables, describing schemas, and executing queries.

## Features

- **Connect to SQLite databases**: Connect to any SQLite database file
- **List tables**: Get all table names in the database  
- **Describe table schemas**: View column definitions, types, and constraints
- **Query data**: Execute SELECT queries with automatic result formatting
- **Execute queries**: Run INSERT, UPDATE, DELETE and other SQL operations
- **Get comprehensive table info**: View schema, indexes, row counts, and sample data

## Installation

```bash
npm install
npm run build
```

## Usage

### As an MCP Server

Add to your MCP client configuration:

```json
{
  "mcpServers": {
    "sqlite": {
      "command": "node",
      "args": ["path/to/dist/index.js"],
      "env": {}
    }
  }
}
```

### Available Tools

1. **connect_database** - Connect to a SQLite database file
   - `path`: Path to the SQLite database file
   - `readonly`: Optional boolean to open in read-only mode

2. **list_tables** - List all tables in the connected database

3. **describe_table** - Get the schema/structure of a specific table
   - `table_name`: Name of the table to describe

4. **query_data** - Execute a SELECT query on the database
   - `query`: SQL SELECT query to execute
   - `limit`: Optional maximum number of rows to return (default: 100)

5. **execute_query** - Execute any SQL query (INSERT, UPDATE, DELETE, etc.)
   - `query`: SQL query to execute

6. **get_table_info** - Get comprehensive information about a table
   - `table_name`: Name of the table to analyze
   - `sample_rows`: Optional number of sample rows to return (default: 5)

## Example Usage

1. First connect to a database:
   ```
   Tool: connect_database
   Args: {"path": "./sample.db"}
   ```

2. List all tables:
   ```
   Tool: list_tables
   ```

3. Get detailed information about a table:
   ```
   Tool: get_table_info
   Args: {"table_name": "users", "sample_rows": 3}
   ```

4. Query data:
   ```
   Tool: query_data
   Args: {"query": "SELECT * FROM users WHERE active = 1", "limit": 10}
   ```

## Development

```bash
# Build TypeScript
npm run build

# Watch for changes during development
npm run dev

# Start the server
npm start
```

## Requirements

- Node.js 18 or higher
- SQLite database files

## Security Notes

- The server can execute any SQL query, so ensure proper access controls
- Consider using read-only mode for sensitive databases
- SQL injection protection is the responsibility of the query author