mcporter Skill: Call Any MCP Server From Your Terminal or TypeScript Code

31,000+ downloads and 87 stars — mcporter by @steipete (Peter Steinberger) is the developer's Swiss Army knife for the Model Context Protocol. Where most MCP tooling focuses on helping users consume pre-configured servers, mcporter focuses on working with MCP servers as a developer: discovering what's available, calling tools directly, generating typed client code, and minting standalone CLIs.

It's the tool you reach for when the question is "what MCP servers do I have configured?" or "let me just call this tool directly without writing a client."

What MCP Is (and Why Direct Access Matters)

The Model Context Protocol is the standard for exposing tools and data sources to AI agents. An MCP server exposes a set of "tools" — functions the agent can call with structured inputs and get structured outputs. Your code editor's MCP config might have servers for GitHub, Linear, a custom database, a web scraper, and so on.

The standard way to interact with these servers is through an AI agent (Claude, Codex, etc.) that's configured to use them. But that workflow has friction: you can't easily inspect what a server actually exposes, test a specific tool with specific inputs, or call a tool without the full agent intermediary.

mcporter solves this. It lets you work with MCP servers directly — from the terminal or TypeScript code — with zero additional configuration.

Zero-Config Discovery

mcporter automatically detects MCP servers from your existing configurations:

# See all MCP servers you have configured
npx mcporter list

It reads from Cursor, Claude Code/Desktop, Codex, Windsurf, and local override files — merging settings and expanding environment variables. If you've configured MCP servers in any of these tools, mcporter list shows them immediately with no additional setup.

# See all tools a specific server exposes, with JSON schemas
mcporter list linear --schema

This is genuinely useful for exploration. Want to know what inputs linear.create_issue actually accepts? mcporter list linear --schema gives you the complete JSON schema in seconds, without opening documentation.

Core Commands

Calling Tools

Multiple syntaxes depending on what's more natural:

# Key=value (most common)
mcporter call linear.list_issues team=ENG limit:5
 
# Function syntax
mcporter call "linear.create_issue(title: \"Bug\", priority: 1)"
 
# Full URL (ad-hoc, no config needed)
mcporter call https://api.example.com/mcp.fetch url:https://example.com
 
# Stdio server (run on demand)
mcporter call --stdio "bun run ./server.ts" scrape url=https://example.com
 
# JSON payload for complex inputs
mcporter call linear.create_issue --args '{"title":"Bug","description":"Details","priority":1}'

The distinction between = and : matters: = passes strings, : parses as JSON (numbers, booleans, objects). Use :5 for numbers, =text for strings.

Machine-Readable Output

mcporter call linear.list_issues team=ENG --output json

--output json returns clean JSON, perfect for piping into other tools or agent processing.

Authentication

# OAuth flow for a configured server
mcporter auth linear
 
# Reset existing auth
mcporter auth linear --reset

Ad-Hoc Servers (No Config Required)

One of mcporter's most useful features: you can call any MCP server by URL without adding it to your config first:

# Call an HTTP MCP server directly
mcporter call https://api.example.com/mcp.fetch url:https://example.com
 
# Or stdio
mcporter call --stdio "python3 ./my-server.py" tool_name arg=value

This means you can test an MCP server you just built, try out a public MCP endpoint, or call a one-off server without polluting your permanent config.

Code Generation

Generate a Standalone CLI

Turn any MCP server into a custom CLI:

# Generate CLI for a configured server
mcporter generate-cli --server linear
 
# Generate from a URL
mcporter generate-cli --command https://api.example.com/mcp

This creates a ready-to-run command-line tool you can share with teammates who don't have mcporter installed. Each generated CLI is a single-purpose tool wrapping one MCP server's tools.

Generate TypeScript Types and Clients

# Emit TypeScript client
mcporter emit-ts linear --mode client
 
# Emit just type definitions
mcporter emit-ts linear --mode types

The generated client code gives you camelCase method calls with full TypeScript types — no hand-written MCP plumbing required. Useful when building applications that need to call MCP servers directly without going through an agent.

Daemon Mode

For long-running workflows where you're making repeated MCP calls:

mcporter daemon start    # Start background daemon
mcporter daemon status   # Check if running
mcporter daemon stop     # Shut down

The daemon maintains persistent connections to MCP servers, improving performance for high-frequency tool calls compared to launching a fresh connection each time.

Comparison: mcporter vs Alternatives

How to Install

clawhub install mcporter

Or use without installing at all:

npx mcporter list

For permanent installation:

# npm/pnpm
pnpm add mcporter
 
# Homebrew
brew tap steipete/tap && brew install steipete/tap/mcporter

No environment variables required for basic use — mcporter reads from your existing MCP configuration files automatically.

Practical Tips

1. Start with mcporter list — Before reaching for documentation, run this to see exactly what servers and tools you actually have available.

2. Use --schema to understand inputs — Before writing complex tool calls, inspect the schema first. This prevents type errors and shows you optional vs required fields.

3. Use --output json in scripts — For any automation, machine-readable output is essential. Add --output json and pipe to jq or your processing tool.

4. Ad-hoc calls for testing — When building a new MCP server, test it with --stdio before integrating it anywhere. Much faster feedback than going through Claude.

5. emit-ts for production integrations — If you're building an app that calls MCP servers, generated TypeScript clients are more maintainable than hand-written call code.

6. generate-cli for team distribution — When you have a useful MCP server and want teammates to call it without mcporter, generate-cli creates a self-contained tool they can use directly.

Considerations

• Developer-focused — mcporter is primarily a developer tool. If you just want to use MCP servers through an agent, you don't need it. Its value is for inspecting, testing, and integrating with MCP programmatically.
• Config file locations vary — It reads from multiple tools' config files. If a server isn't showing up in mcporter list, check that your config file path matches what mcporter expects for your environment.
• Stdio servers are process-spawning — --stdio mode launches a subprocess. This is intentional but means stdio server calls have higher overhead than HTTP connections.
• OAuth flows require a browser — mcporter auth opens a browser for the OAuth flow. This doesn't work in fully headless environments.

The Bigger Picture

The MCP ecosystem is maturing rapidly. More servers, more tools, more configurations. But the developer experience for working with that ecosystem directly — testing, debugging, integrating — has lagged behind.

mcporter fills that gap. It's the tool that makes MCP servers accessible from the command line, the way curl makes HTTP APIs accessible. Once you can inspect and call any server directly, building on top of the MCP ecosystem becomes significantly more productive.

With 31,000+ downloads, it's found its audience primarily among developers who are building with MCP rather than just using it.

View the skill on ClawHub: mcporter