open-index/open-npm huggingface dataset:
npm package: @mcp-z/cli
Description: CLI tool for managing MCP server clusters and testing workflows.
Author: Kevin Malakoff
Latest version: 1.0.5

# @mcp-z/cli

Docs: https://mcp-z.github.io/cli
MCP server lifecycle management and inspection from the command line.

## Common uses

- Spawn servers from `.mcp.json`
- Inspect tools, resources, prompts, and health
- Call tools, prompts, and resources directly
- Search capabilities across servers
- Generate or validate `server.json`

## Install

```bash
npm install -g @mcp-z/cli
```

## Quick start

### Stdio servers

```json
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["path/to/server.js"]
    }
  }
}
```

```bash
mcp-z up
```

### HTTP servers

```json
{
  "mcpServers": {
    "my-server": {
      "type": "http",
      "url": "http://localhost:3000/mcp"
    }
  }
}
```

```bash
mcp-z up
```

### HTTP + start block (extension)

```json
{
  "mcpServers": {
    "my-server": {
      "type": "http",
      "url": "http://localhost:3000/mcp",
      "start": {
        "command": "node",
        "args": ["path/to/http-server.js"]
      }
    }
  }
}
```

`start` is an extension used by `npx @mcp-z/cli up` to launch HTTP servers for you.

## Commands

### `mcp-z up`

Start MCP servers from `.mcp.json`.

Common use cases:
- Start stdio servers for local development
- Start HTTP servers with `start` blocks

### `mcp-z inspect`

Inspect tools, resources, prompts, and health.

Common use cases:
- See what a server exposes before writing code
- Debug startup issues

### `mcp-z call-tool`

Call a tool with JSON arguments.

Common use cases:
- Test a tool without writing code
- Script quick one-offs

### `mcp-z get-prompt`

Get a prompt with optional JSON arguments.

Common use cases:
- Preview prompt outputs
- Validate prompt arguments

### `mcp-z read-resource`

Read a resource by URI.

Common use cases:
- Fetch file-backed resources
- Verify resource handlers

### `mcp-z search`

Search tools, prompts, and resources across servers.

Common use cases:
- Discover capabilities by keyword
- Find the right tool in multi-server setups

### `mcp-z manifest`

Generate or validate `server.json`.

Common use cases:
- Author or validate MCP server manifests

## Inline usage

```bash
# Stdio
mcp-z inspect --run "npx -y @modelcontextprotocol/server-everything"

# HTTP
mcp-z inspect --url "https://api.example.com/mcp"
```

## Configuration

MCP server config supports stdio and HTTP.

**Stdio**
```json
{
  "command": "node",
  "args": ["server.js"],
  "env": { "LOG_LEVEL": "info" }
}
```

**HTTP**
```json
{
  "type": "http",
  "url": "http://localhost:3000/mcp",
  "headers": { "Authorization": "Bearer token" }
}
```

## Requirements

- Node.js >= 24
npm package: @mcp-z/email
Description: Email processing toolkit with base schemas, normalization utilities, and shared constants for Gmail/Outlook integration
Author: Kevin Malakoff
Latest version: 1.0.2

# @mcp-z/email

Docs: https://mcp-z.github.io/email
Provider-agnostic email utilities for parsing, normalization, and query schemas.

## Common uses

- Normalize Gmail/Outlook messages to a shared shape
- Parse and format email addresses
- Build shared query schemas across providers
- Extract clean text from HTML threads

## Install

```bash
npm install @mcp-z/email
```

## Quick start

### Parse addresses

```ts
import { parseAddresses, formatAddresses } from '@mcp-z/email';

const parsed = parseAddresses('John Doe <john@example.com>, jane@example.com');
const formatted = formatAddresses(parsed);
```

### Base query fields

```ts
import { baseEmailQueryFields } from '@mcp-z/email';
import { z } from 'zod';

const QuerySchema = z.object({
  ...baseEmailQueryFields
});
```

## Examples by category

### Parsing and normalization

```ts
import { normalizeDateToISO, stripHtml } from '@mcp-z/email';

const iso = normalizeDateToISO('Wed, 11 Sep 2024 10:30:00 -0400');
const text = stripHtml('<div>Hello <b>World</b></div>');
```

### Thread extraction

```ts
import { extractCurrentMessageFromHtmlToText, extractCurrentMessageFromText } from '@mcp-z/email';

const textFromHtml = extractCurrentMessageFromHtmlToText('<div>New reply</div><blockquote>Old</blockquote>');
const textFromPlain = extractCurrentMessageFromText('New reply\n\n> Old message');
```

### Query schemas

```ts
import { baseEmailQueryFields, FieldOperatorSchema } from '@mcp-z/email';
import { z } from 'zod';

const QuerySchema = z.object({
  ...baseEmailQueryFields,
  label: FieldOperatorSchema.optional()
});
```

### Tool input schemas

```ts
import { ComposeContentTypeSchema, createEmailRecipientsSchema } from '@mcp-z/email';
import { z } from 'zod';

const InputSchema = z.object({
  to: createEmailRecipientsSchema('To recipients'),
  body: z.string().min(1),
  contentType: ComposeContentTypeSchema.optional()
});
```

### Response helpers

```ts
import { buildContentForItems } from '@mcp-z/email';

const content = buildContentForItems([{ id: '1', subject: 'Hello' }], 'emails');
```

## API overview

- Address helpers: `parseAddresses()`, `formatAddresses()`
- HTML/text helpers: `stripHtml()`, `extractCurrentMessageFromHtml()`, `extractCurrentMessageFromHtmlToText()`, `extractCurrentMessageFromText()`
- Date helpers: `normalizeDateToISO()`
- Query helpers: `baseEmailQueryFields`, `FieldOperatorSchema`, `EMAIL_FIELDS`, `EMAIL_FIELD_DESCRIPTIONS`, `EMAIL_COMMON_PATTERNS`
- Schemas: `EmailSummarySchema`, `EmailDetailSchema`, `EmailContentTypeSchema`, `ExcludeThreadHistorySchema`
- Tool helpers: `createEmailRecipientsSchema()`, `createMessageResultSchema()`, `ComposeContentTypeSchema`
- Content helpers: `buildContentForItems()`
- Utils: `safeBase64UrlDecode()`

## Requirements

- Node.js >= 22
npm package: @mcp-z/oauth
Description: Multi-account orchestration and secure token storage for OAuth-based MCP servers
Author: Kevin Malakoff
Latest version: 1.0.1

# @mcp-z/oauth

Docs: https://mcp-z.github.io/oauth
Multi-account OAuth orchestration and token storage for MCP servers.

## Common uses

- Add consistent account tools to MCP servers
- Store OAuth tokens with a shared config and storage backend
- Reuse the same account lifecycle across Google and Microsoft providers

## Install

```bash
npm install @mcp-z/oauth
```

Optional storage backends:

```bash
npm install keyv-duckdb
npm install keyv-file
```

## Initialize token storage

```bash
npx @mcp-z/oauth init
```

This creates a `.tokens/` directory and a default config file for token storage.

## Account tools and modes

Use `AccountServer` to add account tools to your MCP server.

### Loopback mode (multi-account)

When using loopback OAuth, these tools are added:

- `account-me`
- `account-switch`
- `account-remove`
- `account-list`

### Stateless mode (DCR/bearer)

When using stateless auth (DCR/bearer tokens), only this tool is available:

- `account-me`

## Example

```ts
import { AccountServer } from '@mcp-z/oauth';

const { tools, prompts } = AccountServer.createLoopback({
  service: 'gmail',
  store: tokenStore,
  logger,
  auth: authProvider
});
```

## Logging helper

Use `sanitizeForLoggingFormatter` to avoid leaking secrets in logs.

## Requirements

- Node.js >= 22
npm package: @mcp-z/server
Description: Shared utilities and server orchestration for building MCP (Model Context Protocol) servers
Author: Kevin Malakoff
Latest version: 1.0.4

# @mcp-z/server

Docs: https://mcp-z.github.io/server
Shared utilities for building MCP servers with stdio + HTTP transports, middleware composition, and file serving.

## Common uses

- Parse transport config for stdio or HTTP
- Wire MCP servers to stdio or Express HTTP
- Compose auth/logging middleware
- Serve generated files (PDFs, CSVs)
- Build field/pagination/shape schemas

## Install

```bash
npm install @mcp-z/server
```

Peer dependencies:

```bash
npm install @modelcontextprotocol/sdk express
```

## Quick start

```ts
import express from 'express';
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { parseConfig, connectStdio, connectHttp } from '@mcp-z/server';

const mcpServer = new McpServer({ name: 'my-server', version: '1.0.0' });
const config = parseConfig(process.argv.slice(2), process.env);

if (config.transport.type === 'stdio') {
  await connectStdio(mcpServer, { logger: console });
} else {
  const app = express();
  await connectHttp(mcpServer, { logger: console, app, port: config.transport.port });
}
```

## Registration helpers

- `registerTools(server, tools)`
- `registerResources(server, resources)`
- `registerPrompts(server, prompts)`

## Middleware composition

Use `composeMiddleware` with middleware layers (auth, logging, etc.):

```ts
import { composeMiddleware, createLoggingMiddleware } from '@mcp-z/server';

const logging = createLoggingMiddleware({ logger: console });
const composed = composeMiddleware({ tools, resources, prompts }, [
  { withTool: authMiddleware.withToolAuth, withResource: authMiddleware.withResourceAuth, withPrompt: authMiddleware.withPromptAuth },
  { withTool: logging.withToolLogging, withResource: logging.withResourceLogging, withPrompt: logging.withPromptLogging }
]);
```

## File serving utilities

For servers that generate files (PDFs, CSVs, images):

- `reserveFile()` - Reserve a file path for streaming writes
- `writeFile()` - Write a buffer directly
- `getFileUri()` - `file://` or `http://` URI based on transport
- `createFileServingRouter()` - Express router to serve files

```ts
import { reserveFile, getFileUri, createFileServingRouter } from '@mcp-z/server';

const reservation = await reserveFile('report.csv', { resourceStoreUri: 'file:///tmp/files' });
const uri = getFileUri(reservation.storedName, transport, {
  resourceStoreUri: 'file:///tmp/files',
  baseUrl: 'https://example.com',
  endpoint: '/files'
});

const router = createFileServingRouter({ resourceStoreUri: 'file:///tmp/files' }, { contentType: 'text/csv' });
app.use('/files', router);
```

## Schema helpers

Helpers for consistent tool inputs and output shaping:

- `createFieldsSchema()` / `parseFields()` / `filterFields()`
- `createPaginationSchema()`
- `createShapeSchema()` / `toColumnarFormat()`

## Requirements

- Node.js >= 24
npm package: @mcp1.ai/wrapper
Description: Express wrapper for MCP (Model Context Protocol) server
Latest version: 1.0.0

# MCP Wrapper

A simple Express server wrapper for MCP (Model Context Protocol) that forwards HTTP JSON-RPC requests to any command-line process following the JSON-RPC 2.0 protocol, and returns the responses to the client.

## Features

- Receives JSON-RPC 2.0 requests via HTTP
- Forwards requests to the standard input of a specified command-line process
- Captures JSON-RPC responses from the standard output of the process
- Returns responses to the HTTP client
- Automatically restarts crashed processes
- Flexible configuration of target process and arguments

## Installation

```bash
# Install globally
npm install -g @mcp1.ai/wrapper

# Or install as a project dependency
npm install --save @mcp1.ai/wrapper
```

## Usage

### Starting the Server

When installed globally, you can use the CLI directly:

```bash
# Default: uses npx -y @modelcontextprotocol/server-everything
mcp1-wrapper

# Specify a custom process and arguments
mcp1-wrapper <process> [arg1 arg2 ...]

# Example: using uvx mcp-server-fetch
mcp1-wrapper uvx mcp-server-fetch

# Or run a custom JavaScript script
mcp1-wrapper node my-custom-script.js
```

Or when used as a module in your project:

```bash
# Using the package in your project
node node_modules/.bin/mcp1-wrapper <process> [arg1 arg2 ...]
```

### Sending Requests

Once the server is running, you can send JSON-RPC 2.0 requests via HTTP POST to `http://localhost:3000`.

For example, using curl:

```bash
curl -X POST http://localhost:3000 \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": "1",
    "method": "initialize",
    "params": {
      "protocolVersion": "0.1.0",
      "capabilities": {
        "tools": true
      },
      "clientInfo": {
        "name": "MCP Test Client",
        "version": "1.0.0"
      }
    }
  }'
```

## JSON-RPC Request Examples

The package includes several predefined JSON-RPC request examples:

- `initialize.json` - Initialize the MCP server
- `tools-list.json` - Get a list of available tools
- `tools-call.json` - Call a specific tool

You can use these example files to quickly test the server:

```bash
# Use curl to send the tools-list request
curl -X POST http://localhost:3000 -H "Content-Type: application/json" -d @path/to/tools-list.json
```

## Automatic Process Restart

The Express server monitors the child process status and automatically restarts the process if it unexpectedly exits. This ensures high availability of the service, even if the underlying process crashes.

The restart logic includes:

- Detecting process exit events
- Restarting the process after a short delay (to avoid crash loops)
- Handling process switching in request processing

## Notes

- The server runs on port 3000 by default
- Request timeout is set to 30 seconds
- Process restart has a 1-second delay to avoid crash loops
- Child processes are automatically terminated when the server is shut down

## License

MIT
npm package: @mcp3/dex-screener
Description: DexScreener API integration for MCP3
Latest version: 1.0.8

# DexScreener API Integration (Model Context Protocol)

A TypeScript implementation of the Model Context Protocol for the DexScreener API.

## Features

- MCP server integration for DexScreener API
- Query token profiles and boosts
- Search for pairs matching specific criteria
- Get pairs by chain and pair address
- Get pools of a given token address
- Get pairs by token address
- TypeScript support
- Command-line interface

## Prerequisites

- Node.js (v16 or higher)
- pnpm (v7 or higher)

## Installation

1. Clone the repository:
```bash
git clone <repository-url>
cd mcp3
```

2. Install dependencies:
```bash
pnpm install
```

3. Build the package:
```bash
pnpm --filter @mcp3/dex-screener build
```

## Usage

### As a library

```typescript
import { DexScreenerClient } from '@mcp3/dex-screener';

// Initialize the client
const client = new DexScreenerClient();

// Get pairs by token address
const pairs = await client.getPairsByTokenAddress('ethereum', '0x1234...');
console.log(pairs);
```

### Command Line

```bash
# Get token profiles
pnpm --filter @mcp3/dex-screener start dexscreener-get-token-profiles

# Search for pairs
pnpm --filter @mcp3/dex-screener start dexscreener-search-pairs --q "ETH/USDT"

# Get pairs by token address
pnpm --filter @mcp3/dex-screener start dexscreener-get-pairs-by-token --chain ethereum --token 0x1234...
```

## API Reference

This package integrates with the DexScreener API. For more information, see the [DexScreener API documentation](https://docs.dexscreener.com/api/reference).

## License

MIT
npm package: @mcp3/sentio
Description: Sentio API integration for MCP3
Latest version: 1.0.3

# @mcp3/sentio

A Sentio API integration package for MCP3, providing tools to interact with Sentio analytics API.

## Installation

```bash
pnpm install @mcp3/sentio
```

## Features

- Query TVL (Total Value Locked) data from Sentio API

## Usage

### As a library

```typescript
import { register } from '@mcp3/sentio';
import { Registration } from '@mcp3/common';

const registration = new Registration();
register(registration);

// Use registration with your application
```

### CLI

```bash
# Query TVL data for a protocol
sentio-cli sentio-tvl-data --protocol <protocol-name>

# Query TVL data with additional parameters
sentio-cli sentio-tvl-data --protocol <protocol-name> --chain <chain-name> --from-timestamp <timestamp> --to-timestamp <timestamp> --time-interval 1d
```

## License

MIT
npm package: @mcp3/sui-base
Description: Base utilities and tools for Sui Network in MCP3
Latest version: 1.0.9

# Sui Base (Model Context Protocol)

Base utilities and tools for Sui Network in MCP3. This package provides common functionality used by other Sui-related packages.

## Features

- Core Sui network interaction utilities
- Common tools for interacting with the Sui blockchain
- Resource registration for Sui resources
- CLI utilities for Sui-based applications

## Usage

This package is primarily used as a dependency for other Sui-related packages in the MCP3 ecosystem.

### As a dependency

```typescript
import { 
  downloadABI, 
  callViewFunction, 
  queryEvents, 
  registerSUIBaseTools 
} from '@mcp3/sui-base';

// Use the utilities
const abi = await downloadABI(nodeUrl, packageId);
```

### Core Functions

#### Download ABI

```typescript
import { downloadABI } from '@mcp3/sui-base';

// Download ABI for a package
const abi = await downloadABI(nodeUrl, packageId);
```

#### Call View Function

```typescript
import { callViewFunction } from '@mcp3/sui-base';

// Call a view function
const result = await callViewFunction({
  nodeUrl: 'https://fullnode.mainnet.sui.io:443',
  packageId: '0x2',
  module: 'coin',
  functionName: 'balance',
  params: ['0x123'],
  typeArguments: ['0x2::sui::SUI']
});
```

#### Query Events

```typescript
import { queryEvents, parseEventFilter } from '@mcp3/sui-base';

// Query events
const filter = parseEventFilter('0x2::coin::CoinEvent');
const events = await queryEvents({
  nodeUrl: 'https://fullnode.mainnet.sui.io:443',
  filter,
  limit: 10,
  descending: false
});
```

## License

MIT
npm package: @mcp3/sui-cetus
Description: Cetus Protocol integration for Sui Network in MCP3
Latest version: 1.0.9

# Sui Cetus (Model Context Protocol)

A TypeScript implementation of the Model Context Protocol for the Cetus Protocol on Sui Network.

## Features

- MCP server integration for Cetus Protocol
- Connect to Sui network nodes
- Query Cetus Protocol data and interact with Cetus contracts
- Retrieve pool information and user positions
- Perform swaps and manage liquidity
- Get rewards and fees
- TypeScript support
- Command-line interface

## Prerequisites

- Node.js (v16 or higher)
- pnpm (v7 or higher)

## Installation

1. Clone the repository:
```bash
git clone <repository-url>
cd mcp3
```

2. Install dependencies:
```bash
pnpm install
```

3. Build the package:
```bash
pnpm --filter @mcp3/sui-cetus build
```

## Usage

### As a module

This package is primarily designed to be used as a CLI tool or as part of the MCP3 system. It provides tools for interacting with the Cetus Protocol on the Sui Network.

### As a CLI tool

```bash
# Get help
sui-cetus --help

# Get pool information
sui-cetus pool-info

# Get positions for an address
sui-cetus positions <address>
```

## CLI Commands

The package provides the following CLI commands:

- `sui-cetus-pool-info`: Get information about Cetus Protocol pools
- `sui-cetus-positions`: Get positions for a specific address
- `sui-cetus-swap-quote`: Get a quote for swapping tokens
- `sui-cetus-liquidity-calc`: Calculate liquidity and coin amounts
- `sui-cetus-add-liquidity`: Add liquidity to a Cetus Protocol pool
- `sui-cetus-fees`: Calculate fees for a position
- `sui-cetus-rewards`: Calculate rewards for a position
- `sui-cetus-apr`: Calculate APR for a pool or position
- `sui-cetus-deposit`: Deposit tokens into a Cetus Protocol liquidity pool
- `sui-cetus-withdraw`: Withdraw tokens from a Cetus Protocol liquidity position

## License

MIT
npm package: @mcp3/sui-navi
Description: Navi Protocol integration for Sui Network in MCP3
Latest version: 1.0.8

# Sui Navi (Model Context Protocol)

A TypeScript implementation of the Model Context Protocol for the Navi Protocol on Sui Network.

## Features

- MCP server integration for Navi Protocol
- Connect to Sui network nodes
- Query Navi Protocol data and interact with Navi contracts
- Retrieve pool information and user balances
- Get health factors and available rewards
- TypeScript support
- Command-line interface

## Prerequisites

- Node.js (v16 or higher)
- pnpm (v7 or higher)

## Installation

1. Clone the repository:
```bash
git clone <repository-url>
cd mcp3
```

2. Install dependencies:
```bash
pnpm install
```

3. Build the package:
```bash
pnpm --filter @mcp3/sui-navi build
```

## Usage

### As a library

```typescript
import { NaviClient } from '@mcp3/sui-navi';

// Initialize the client
const client = new NaviClient({
  networkType: 'mainnet'
});

// Get pool information
const poolInfo = await client.getPoolInfo();
console.log(poolInfo);
```

### As a CLI tool

```bash
# Get help
sui-navi --help

# Get pool information
sui-navi pool-info

# Get health factor for an address
sui-navi health-factor <address>
```

## API Reference

The package exposes the following main classes and functions:

- `NaviClient`: Main client for interacting with Navi Protocol
- `getPoolInfo()`: Get information about Navi pools
- `getHealthFactor()`: Get health factor for a specific address
- `getAvailableRewards()`: Get available rewards for an address

## License

MIT
npm package: @mcp3/transaction-ui
Description: A React component library for Sui transaction signing and submission
Author: MCP3 Team
Latest version: 1.0.5

# Transaction UI

A React component library for Sui transaction signing and submission.

## Features

- React components for displaying and signing Sui transactions
- Integration with @mysten/dapp-kit for wallet connections
- Direct transaction submission to the Sui blockchain
- Styled with Tailwind CSS and shadcn/ui components
- TypeScript support

## Installation

```bash
npm install @mcp3/transaction-ui
```

## Usage

### Basic Usage

```tsx
import { TransactionPage, Providers } from '@mcp3/transaction-ui';
import '@mcp3/transaction-ui/styles.css';

function App() {
  return (
    <Providers>
      <TransactionPage txId="your-transaction-id" />
    </Providers>
  );
}
```

### With React Router

```tsx
import { BrowserRouter, Routes, Route, useParams } from 'react-router-dom';
import { TransactionPage, Providers } from '@mcp3/transaction-ui';
import '@mcp3/transaction-ui/styles.css';

function App() {
  return (
    <Providers>
      <BrowserRouter>
        <Routes>
          <Route path="/sui/tx/:txId" element={<TransactionRoute />} />
        </Routes>
      </BrowserRouter>
    </Providers>
  );
}

function TransactionRoute() {
  const { txId } = useParams<{ txId: string }>();
  return <TransactionPage txId={txId} />;
}
```

## Components

### TransactionPage

The main component for displaying and signing transactions.

```tsx
<TransactionPage txId="your-transaction-id" />
```

### Providers

Provides the necessary context for the transaction components.

```tsx
<Providers>
  {/* Your components */}
</Providers>
```

## Development

```bash
# Install dependencies
npm install

# Start the development server
npm run dev

# Build the library
npm run build:lib
```

## License

MIT
npm package: @mcp_factory/canva-mcp-server
Description: MCP server for Canva - manage designs, folders, assets, brand templates, exports, and comments via the Canva Connect API
Latest version: 1.0.0

# @mcp_factory/canva-mcp-server

MCP (Model Context Protocol) server for Canva.

MCP server for Canva - manage designs, folders, assets, brand templates, exports, and comments via the Canva Connect API

## Installation

```bash
npx @mcp_factory/canva-mcp-server
```

Or install globally:

```bash
npm install -g @mcp_factory/canva-mcp-server
```

## Authentication

### OAuth Setup
This server uses OAuth authentication. Configure via MCP Bind or set:
- `CANVA_CLIENT_ID`: Your OAuth client ID
- `CANVA_CLIENT_SECRET`: Your OAuth client secret

## Available Tools

- **canva_list_users_me**: Get the authenticated user's ID and team ID
- **canva_list_me_profile**: Get the authenticated user's profile information including display name
- **canva_list_designs**: List and search the user's designs with filtering and sorting
- **canva_create_designs**: Create a new Canva design (doc, presentation, whiteboard, or custom size)
- **canva_get_designs**: Get metadata for a specific design including title, thumbnail, URLs, and page count
- **canva_get_designs_pages**: Get all pages of a design with thumbnails
- **canva_create_exports**: Start an export job to convert a design to PDF, PNG, JPG, PPTX, GIF, or MP4
- **canva_get_exports**: Get the status and download URLs of an export job
- **canva_create_folders**: Create a new folder in the user's Canva projects
- **canva_get_folders**: Get metadata for a specific folder
- **canva_update_folders**: Rename a folder
- **canva_delete_folders**: Delete a folder and its contents
- **canva_get_folders_items**: List items (designs, folders, images) inside a folder
- **canva_create_folders_move**: Move a design, folder, or image to a different folder
- **canva_get_assets**: Get metadata for an uploaded asset (image or video)
- **canva_update_assets**: Update an asset's name and tags
- **canva_delete_assets**: Delete an uploaded asset
- **canva_list_brand_templates**: List brand templates available in the team (Enterprise)
- **canva_get_brand_templates**: Get metadata for a specific brand template
- **canva_get_brand_templates_dataset**: Get the autofill dataset fields for a brand template
- **canva_create_autofills**: Create a design by auto-filling a brand template with text, images, or chart data
- **canva_get_autofills**: Get the status and result of an autofill job
- **canva_create_designs_comments**: Create a new comment thread on a design
- **canva_get_comments_replies**: List replies in a comment thread on a design
- **canva_create_comments_replies**: Reply to a comment thread on a design

## Usage with Claude Desktop

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "canva": {
      "command": "npx",
      "args": ["-y", "@mcp_factory/canva-mcp-server"]
    }
  }
}
```

## Usage with MCP Bind

This server is available on [MCP Bind](https://mcpbind.com). Connect it to your Wexa workspace for seamless integration.

## License

MIT
npm package: @mcp_factory/telegram-mcp-server
Description: MCP server for Telegram - read chats, send messages, manage contacts, search messages. Built-in MTProto auth with OTP verification UI.
Latest version: 1.0.4

# @mcp_factory/telegram-mcp-server

MCP server for Telegram with built-in MTProto authentication.

Read chats, send messages, search across conversations, manage contacts, forward, pin, and delete messages - all through MCP.

## Setup (one time)

### 1. Get Telegram API credentials
Go to https://my.telegram.org/apps and create an app. Copy the `api_id` and `api_hash`.

### 2. Run auth
```bash
TG_API_ID=12345 TG_API_HASH=abc123 npx @mcp_factory/telegram-mcp-server auth
```

A browser window opens where you:
1. Enter your phone number
2. Enter the OTP code from Telegram
3. (If 2FA enabled) Enter your password

Session is saved to `~/.telegram-mcp/session.json`. You only do this once.

## Usage

```bash
TG_API_ID=12345 TG_API_HASH=abc123 npx @mcp_factory/telegram-mcp-server
```

Or in Claude Desktop `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "telegram": {
      "command": "npx",
      "args": ["-y", "@mcp_factory/telegram-mcp-server"],
      "env": {
        "TG_API_ID": "12345",
        "TG_API_HASH": "abc123"
      }
    }
  }
}
```

On first run with no session, the browser opens automatically for login.

## Available Tools (11)

| Tool | Description |
|------|-------------|
| `telegram_get_me` | Get connected user's profile |
| `telegram_list_chats` | List recent chats with unread counts |
| `telegram_get_messages` | Get messages from a chat |
| `telegram_send_message` | Send a message to any chat |
| `telegram_search_messages` | Search messages (in chat or globally) |
| `telegram_get_contacts` | Get contact list |
| `telegram_get_chat_info` | Get chat/group/channel details |
| `telegram_mark_read` | Mark chat as read |
| `telegram_forward_message` | Forward messages between chats |
| `telegram_delete_messages` | Delete messages |
| `telegram_pin_message` | Pin a message in chat |

## Auth Types

| Context | How it works |
|---------|-------------|
| **Standalone** | Built-in web UI: phone + OTP + optional 2FA |
| **MCP Bind / Wexa** | Backend handles MTProto session via `/telegram/sendCode` and `/telegram/verifyCode` APIs |

## Security

- Session stored locally at `~/.telegram-mcp/session.json` (file permissions: 600)
- No data sent to third-party servers
- Session = full account access - treat it like a password
- Only runs on `127.0.0.1` during auth (not exposed to network)

## License

MIT