MCPShim
Remote tools as CLI commands
Use any MCP server or configured HTTP API as a shell command. mcpshim turns remote capabilities into native CLI commands your agent can call directly - no SDKs, no schema bloat, just shell.
Built for command-native tool workflows
The daemon does discovery, auth, and capability management. The CLI stays thin and predictable.
MCP tools become CLI commands
Every remote MCP tool is exposed as a standard shell command with flags that map to tool parameters. Call them from any script, agent, or pipeline.
Dynamic tool discovery
The daemon discovers server capabilities automatically. The CLI surfaces them as callable commands without manual wrapper code.
HTTP APIs become tools
Bind ordinary HTTP endpoints as typed tools or constrained raw requests, with nested JSON templates and policy-controlled access.
Config-driven registration
Config is the source of truth for server registration. Add servers by URL, set auth headers, reload, and keep everything deterministic.
Auth centralized
OAuth tokens, API keys, and header-based auth are centralized behind explicit setup and a local token store.
Agent-ready and composable
Avoid loading huge MCP schemas into model context. Register tools once, invoke only what the agent needs as simple CLI calls.
How it works
mcpshim sits between your agent and remote MCP servers or HTTP APIs. The daemon centralizes discovery, authentication, policy, call execution, and history; the CLI exposes every tool as a standard command.
Define your services
Add MCP endpoints or typed and raw HTTP bindings in YAML. Set aliases, auth headers, policies, and environment references.
Start the daemon
Run mcpshimd to discover configured servers and expose a single Unix socket for the CLI.
Call tools from the shell
Use mcpshim call or generated wrappers - flags become MCP arguments or validated HTTP inputs automatically.
What agents can do with mcpshim
From tool orchestration to context-budget control, mcpshim gives your AI one safe interface for MCP and HTTP capabilities.
Agent tool orchestration
Let your AI agent discover and call remote MCP tools as standard CLI commands instead of embedding entire server SDKs.
Context-efficient tool use
Stop loading hundreds of MCP tool definitions into model context. Call tools by name from the shell - the agent only sees what it invokes.
Unified tool gateway
Route remote MCP servers and configured HTTP APIs through one daemon with centralized auth, history, and policy.
Agent-ready workflows
Focused skills cover setup, discovery, invocation, configuration, health checks, and auditing without loading every MCP schema into context.
mcpshim-install
Install, configure, start, and verify the daemon.
mcpshim-status
Check local daemon health and cached discovery counts.
mcpshim-discover-tools
Find registered servers, available tools, and input schemas.
mcpshim-call-tool
Invoke MCP or HTTP tools with structured arguments.
mcpshim-manage-servers
Manage MCP endpoints, HTTP bindings, auth, and reloads.
mcpshim-read-history
Audit persisted tool-call arguments, outcomes, and timing.
Works with every AI agent
Copilot, Claude, Gemini, Codex - it doesn't matter. If your agent can run a command, it can use any configured tool.
GitHub Copilot
Give Copilot access to remote MCP tools as local commands so it can call APIs, search knowledge bases, and trigger workflows.
Claude
Let Claude invoke remote MCP tools through thin shell commands - no SDK bloat in context, just call what it needs.
Gemini
Connect Gemini to your MCP servers so it can discover tools, run queries, and chain actions across services.
Codex
Equip Codex with MCP-backed commands to fetch data, run operations, and report results without context overhead.
OpenCode
Let OpenCode reach remote MCP tools as lightweight shell commands - discover, call, and chain actions without context bloat.
Any Agent
mcpshim is agent-agnostic. Any AI that can run a shell command or read from a Unix socket gets instant MCP access.
mcpshim exposes MCP and configured HTTP tools as standard CLI commands. Any AI agent that supports tool-use, function calling, or shell execution can call them directly.
Get started in seconds
Let your AI agent set things up, or install manually with Go.
1. Give your agent the install skill
Run this command to download the MCPShim install skill. Then ask your agent to follow the instructions inside.
curl -fsSL https://raw.githubusercontent.com/mcpshim/skills/refs/heads/main/mcpshim-install/SKILL.md -o MCPSHIM_INSTALL.md2. Ask your agent to install MCPShim
Paste something like this into your agent's chat:
“Read MCPSHIM_INSTALL.md and follow the instructions to install mcpshim, configure it with the MCP servers I need, start the daemon, and verify with mcpshim status.”
Your agent will install the binaries, create the config, start the daemon, and verify everything is working - autonomously.
One daemon, all your remote tools
Your agent doesn't need to implement MCP transport, store OAuth tokens, or load every capability schema. mcpshim keeps those concerns behind a small CLI.
- Centralized access to MCP servers and configured HTTP APIs
- SQLite-backed call history and OAuth token storage
- Config-driven typed and raw HTTP tools with hot reload
- JSON IPC protocol over Unix domain socket
- Wrapper scripts for short aliases (mcpshim script --install)
Give your agent a voice too
MCPShim gives your agent tools. Pantalk gives it a voice - putting the coding agent you already run into Slack, Discord, Telegram, WhatsApp, SMS, and eight more chat apps. Together they form a complete agent infrastructure stack.
Build with us
mcpshim is open source. Follow development on GitHub, report issues, or contribute improvements.