open-index/open-npm huggingface dataset:
npm package: @iflow-mcp/marktisham-lumostradetool
Description: Node.js + TypeScript MCP server deployed to Cloud Run as lumos-tool-trade.
Latest version: 0.1.1

# LumosTradeTool (Node MCP)

Node.js + TypeScript MCP server deployed to Cloud Run as lumos-tool-trade.

## Add a tool

1. Create a new file under src/tools/ (or copy src/tools/_TEMPLATE.ts).
2. Export a register function that calls server.tool(...).
3. Register it in src/tools/registerTools.ts.

## Local run

- Tool server: ./lumos run lumostradetool
- MCP endpoint: http://127.0.0.1:8082/mcp

## Notes

- Keep src/index.ts focused on server boot and wiring.
- Keep tool implementations in src/tools/.
- Add shared helpers under src/lib/.

## Related documentation

- Operations: [../../../docs/OPERATIONS.md](../../../docs/OPERATIONS.md)
npm package: @iflow-mcp/mattcoatsworth-canva-mcp-server
Description: MCP Server for Canva API
Latest version: 1.0.0

# Canva API MCP Server

A comprehensive Model Context Protocol (MCP) server for interacting with Canva's API. This server provides tools and resources for managing designs, brands, assets, and users in Canva.

## Features

- Complete coverage of Canva API endpoints
- Tools for all major API operations
- Resources for documentation and entity details
- Mock data support for testing without API credentials

## Getting Started

1. Clone this repository
2. Install dependencies:
   ```
   npm install
   ```
3. Copy `.env.example` to `.env` and add your Canva API credentials:
   ```
   CANVA_APP_ID=your_app_id
   CANVA_API_KEY=your_api_key
   ```
4. Start the server:
   ```
   npm run dev
   ```

## Testing with MCP Inspector

To test the server with the MCP Inspector:

```
npm run inspect
```

This will open a web interface where you can:
- Browse and test all available tools
- Access resources
- View server logs

## Available Tools

### Design Management
- `get_design` - Get information about a specific design
- `list_designs` - List designs with optional pagination

### Brand Management
- `get_brand` - Get information about a specific brand
- `list_brands` - List brands with optional pagination

### Asset Management
- `get_asset` - Get information about a specific asset
- `list_assets` - List assets with optional filtering and pagination
- `upload_image` - Upload an image to Canva from a URL

### User Management
- `get_user` - Get information about a specific user
- `list_users` - List users with optional pagination

## Available Resources

### Documentation
- `canva://overview` - General API overview
- `canva://getting-started` - Getting started guide
- `canva://authentication` - Authentication information
- `canva://designs` - Designs API documentation
- `canva://brands` - Brands API documentation
- `canva://assets` - Assets API documentation
- `canva://users` - Users API documentation

### Entity Resources
- `canva://design/{designId}` - Information about a specific design
- `canva://brand/{brandId}` - Information about a specific brand
- `canva://asset/{assetId}` - Information about a specific asset

## Mock Data

If no API credentials are provided, the server will use mock data for all responses. This is useful for testing and development.

## License

MIT
npm package: @iflow-mcp/matteoantoci-google-forms-mcp
Description: MCP server for Google Forms integration
Latest version: 0.1.0

[![MseeP.ai Security Assessment Badge](https://mseep.net/pr/matteoantoci-google-forms-mcp-badge.png)](https://mseep.ai/app/matteoantoci-google-forms-mcp)

# Google Forms MCP Server

This MCP server uses the Google Forms API to provide functions such as creating, editing, and retrieving responses for forms.

## Build Method

### Initial Setup
After cloning the repository, install dependencies
```
cd google-forms-mcp
```

### Build the Server
```
# Build the main MCP server
npm run build
```

### Build the Refresh Token Acquisition Script
```
# Build the refresh token acquisition script
npm run build:token
```

### Execution in Development Environment
```
# Run the server directly
node build/index.js

# Or, use npm script
npm run start
```


## Setup Method

1. Create a project in Google Cloud Console and enable the Google Forms API.
   - https://console.cloud.google.com/
   - Search for "Google Forms API" from APIs & Services > Library and enable it.

2. Obtain OAuth 2.0 Client ID and Secret.
   - APIs & Services > Credentials > Create Credentials > OAuth client ID
   - Select Application type: "Desktop app"

3. Set environment variables and obtain the refresh token.
   ```bash
   export GOOGLE_CLIENT_ID="YOUR_CLIENT_ID"
   export GOOGLE_CLIENT_SECRET="YOUR_CLIENT_SECRET"
   cd google-forms-mcp
   npm run build
   node build/get-refresh-token.js
   ```

   Note: If an error occurs when running get-refresh-token.js, execute the following command:
   ```bash
   cd google-forms-mcp
   npm run build:token
   node build/get-refresh-token.js
   ```

4. Copy the displayed refresh token.

5. Update the Claude desktop app's configuration file.
   - Open `~/Library/Application Support/Claude/claude_desktop_config.json`.
   - Add environment variables to the `google-forms-mcp` in the `mcpServers` section:
   ```json
   "google-forms-mcp": {
     "command": "node",
     "args": [
       "/path/to/your/google-forms-mcp/build/index.js" # Update this path
     ],
     "env": {
       "GOOGLE_CLIENT_ID": "YOUR_CLIENT_ID",
       "GOOGLE_CLIENT_SECRET": "YOUR_CLIENT_SECRET",
       "GOOGLE_REFRESH_TOKEN": "YOUR_REFRESH_TOKEN"
     }
   }
   ```

6. Restart the Claude desktop app.

## Available Tools

This MCP server provides the following tools:

1. `create_form` - Create a new Google Form
2. `add_text_question` - Add a text question to the form
3. `add_multiple_choice_question` - Add a multiple choice question to the form
4. `get_form` - Get form details
5. `get_form_responses` - Get form responses

## Usage Example

```
Create a form and add some questions.
```

Claude uses MCP tools like the following to create the form:

1. Use the `create_form` tool to create a new form
2. Use `add_text_question` or `add_multiple_choice_question` tools to add questions
3. Display the URL of the created form
npm package: @iflow-mcp/matthewdailey-mcp-starter
Description: ModelContextProtocol starter server
Latest version: 0.2.1

# MCP Starter Server

A minimal [ModelContextProtocol](https://modelcontextprotocol.io) server template for building AI assistant tools. This starter provides a basic structure for creating MCP tools that can be used with AI assistants like Claude.

## Features

- Simple "hello world" tool example
- TypeScript + esbuild setup
- Development tools preconfigured

## Setup to build and run with Claude

1. Download and install Claude desktop app from [claude.ai/download](https://claude.ai/download)

2. Clone the repo, install dependencies and build:

```
npm install
npm run build
```

3. Configure Claude to use this MCP server. If this is your first MCP server, in the root of this project run:

```bash
echo '{
  "mcpServers": {
    "mcp-starter": {
      "command": "node",
      "args": ["'$PWD'/dist/index.cjs"]
    }
  }
}' > ~/Library/Application\ Support/Claude/claude_desktop_config.json
```

This should result in an entry in your `claude_desktop_config.json` like:

```json
"mcpServers": {
  "mcp-starter": {
    "command": "node",
    "args": ["/Users/matt/code/mcp-starter/dist/index.cjs"]
  }
}
```

If you have existing MCP servers, add the `mcp-starter` block to your existing config. It's an important detail that the `args` is the path to `<path_to_repo_on_your_machine>/mcp-starter/dist/index.cjs`.

4. Restart Claude Desktop.

5. Look for the hammer icon with the number of available tools in Claude's interface to confirm the server is running.

6. If this is all working, you should be able to develop your MCP server using `npm run dev` and test it in Claude. You'll need to restart Claude each time to restart the MCP server.

## Developing with Inspector

For development and debugging purposes, you can use the MCP Inspector tool. The Inspector provides a visual interface for testing and monitoring MCP server interactions.

Visit the [Inspector documentation](https://modelcontextprotocol.io/docs/tools/inspector) for detailed setup instructions.

To test locally with Inspector:
```
npm run inspect
```

To build on file changes run:
```
npm run watch
```

Or run both the watcher and inspector:
```
npm run dev
```

## Publishing

Once you're ready to distribute your server, it's simple! 

1. Set up an [NPM](https://www.npmjs.com/) account.

2. Run `npm publish`. This will publish a package using the project name in `package.json`

3. Once published, others can install the server with a config entry like:

```
"mcpServers": {
  "<your-package-name>": {
    "command": "npx",
    "args": ["<your-package-name>"]
  }
}
```

## Available Tools

The server provides:

- `hello_tool`: A simple example tool that takes a name parameter and returns a greeting

## Creating New Tools

To add new tools:

1. Define the tool schema in `index.ts`
2. Add it to the tools array in the `ListToolsRequestSchema` handler
3. Add the implementation in the `CallToolRequestSchema` handler

See the `hello_tool` implementation as an example.