The idea: Your chatbot already knows how to reason. Remote Access MCP gives that reasoning a controlled pair of hands on a machine you own.
What is Remote Access MCP?
Turn any Linux server into an AI-agent-accessible machine via MCP. ChatGPT, Claude, and Grok connect over HTTPS and control files, shell, git, and more — securely, with zero Python dependencies.
星标
4
工具
—
可用率
—
Model Context Protocol (MCP) lets AI applications use external tools and data. Remote Access MCP is the bridge between an MCP-compatible AI client and a real machine.
Install it on a laptop, desktop, VM, home server, cloud server, or development box. Connect your AI client, grant it only the directories and capabilities it needs, and let the agent actually do the work.
Instead of:
"Here is the error. Tell me what command I should run."
You can have an agentic workflow:
"Inspect the project, reproduce the bug, edit the files, run the tests, check the logs, fix the issue, and tell me exactly what changed."
The AI can perform the loop instead of merely describing it.
Depending on the permissions you grant, an MCP client can:
inspect and understand a codebase
create, edit, move, and delete files
upload and download binary files
run tests, linters, builds, scripts, and development commands
inspect processes, disks, network interfaces, logs, and services
work with Git repositories
query SQLite, MySQL, PostgreSQL, and Redis through controlled adapters
inspect HTTP endpoints and browser pages
create background jobs and run bounded tasks in parallel
schedule recurring work and react to webhooks, file, and health events
diagnose infrastructure and common Docker/Kubernetes environments
create snapshots and roll back risky filesystem changes
use optional Context7, Codebase Memory, and other MCP integrations
That means the AI can follow a real observe → plan → change → test → verify loop.
Why this is different
Most AI chat experiences stop at generated text. Coding agents improve that by giving the model a workspace. Remote Access MCP takes the same idea to the machine itself while keeping the operator in control.
It is designed for:
💻 Laptops & desktops — let your AI work on your local development environment.
to print the connector URL for the current runtime.
Laptop / desktop: no domain required
You do not need to buy a domain or configure port forwarding just to experiment.
ramcp tunnel
Remote Access MCP can use a supported tunnel provider and print a public HTTPS endpoint. Auto mode remembers the last successful provider and prefers it on the next run.
You can also use direct HTTP when appropriate:
ramcp tunnel --direct
Direct mode chooses a high dynamic port rather than common service ports and performs availability/health checks before presenting the endpoint.
Free tunnel providers may assign a new hostname after a tunnel is recreated. A provider's free tier controls hostname persistence, not Remote Access MCP.
Server deployment
For a Linux server with a domain:
ramcp init
ramcp policy allow /srv/myapp
ramcp policy shell on
ramcp service install --domain mcp.example.com
ramcp doctor
ramcp url
The service setup is intended to keep the gateway local and put your chosen HTTPS edge/reverse proxy in front of it.
Agentic workflows
Remote Access MCP is not just a collection of shell wrappers. The toolset is designed so an AI agent can complete multi-step work.
Example: fix a failing project
User:
"The tests are failing. Find the cause, fix it, run the relevant tests,
and verify that the fix didn't break anything else."
Agent:
1. Inspect project structure
2. Read relevant files
3. Run the failing test
4. Inspect output/logs
5. Edit the code
6. Run focused tests
7. Run broader verification
8. Report files changed + results
Example: investigate a server
"Why is this server slow? Check CPU, RAM, disk, processes, network,
logs and services. Identify the bottleneck and propose or perform the
lowest-risk fix, then verify the result."
Example: build something
"Create the project in /srv/demo, install its dependencies, implement
the feature, run the tests and leave me a working build."
The important difference is that the model gets tools + state + feedback, so it can iterate against the real environment.
Safety model
Remote Access MCP is deliberately permission-oriented. Installing it does not mean giving an AI unrestricted root access.
path resolution that handles .. and symlinks before policy checks
deny rules that win over allow rules
timing-safe token verification
secret redaction in operational output
SSRF protections for private/loopback/cloud metadata ranges
Git command/argument validation
SQLite single-statement restrictions and blocked ATTACH
protected service/process controls
bounded command output and timeouts
persistent audit logging with hash-chain verification
filesystem snapshots and rollback support
optional plugin isolation with fail-closed behavior
autonomous recovery disabled by default
Security is not a promise that an AI can never make a mistake. The goal is to make its capabilities explicit, bounded, observable, and revocable.
See SECURITY.md for the security model and reporting guidance.
Background jobs & parallel work
Long-running work does not have to block the request that started it.
The gateway provides bounded worker execution for:
background commands
parallel operations
retries with limits
cancellation
timeouts
captured output
persistent job metadata
per-token ownership
This is useful when an agent needs to build/test several components, wait for a long-running task, or perform independent checks concurrently.
Automation & events
Automation rules can be triggered by intervals and supported tool, webhook, file, and health events. Actions still pass through the normal token policy, scopes, read-only controls, and audit layer.
This lets you build workflows such as:
webhook → inspect deployment → run health checks → collect logs → notify
or:
health event → bounded recovery action → verify → record incident
Autonomous recovery is disabled by default and requires explicit operator configuration.
Plugins & integrations
Optional integrations can extend the gateway without making them mandatory for the core runtime.
Supported/available integrations include:
Context7 for library/documentation context
Codebase Memory for repository-aware code context
Context Mode as an optional local integration
local plugins with validation, fingerprints, namespaced tools, and isolation controls
Each Remote Access MCP instance can keep its Codebase Memory runtime/data/cache identity isolated from other applications on the same machine.
CLI & TUI
The command line remains script-friendly while the interactive terminal UI provides a guided operator experience.
ramcp # interactive TUI in a real terminal
ramcp doctor # diagnose the environment
ramcp status # runtime/service summary
ramcp service status # service state
ramcp service logs -f # follow logs
ramcp tunnel # public connection
ramcp url # current connector URL
ramcp token list # token fingerprints
ramcp audit --verify # verify audit hash chain
The TUI is an operator interface, not a general server-control center. It focuses on configuring, starting, connecting, securing, diagnosing, and operating Remote Access MCP itself.
Core capabilities
Remote Access MCP includes a broad operational toolkit covering:
Docker/Kubernetes/Cloudflare diagnostics where the local CLI is available
Security
secret scanning, local port scanning, audit verification
The exact built-in tool surface can evolve between releases; use the installed version's doctor, documentation, and MCP tool list as the source of truth.
Requirements
Node.js 18+ for the core gateway
Linux, macOS, or Windows
An MCP-compatible client for agent interaction
Optional system utilities depending on the capabilities you want to use
No Python runtime and no Docker runtime are required for the core gateway.
Open source
Remote Access MCP is MIT licensed and intended to be useful as infrastructure for developers, self-hosters, AI-agent builders, and automation projects.
git clone https://github.com/AmirAliManzar/remote-access-mcp.git
cd remote-access-mcp
npm install
npm test
npm run build
Contributions, bug reports, security reports, ideas, and real-world agent workflows are welcome.
Turn any Linux server into an AI-agent-accessible machine via MCP. ChatGPT, Claude, and Grok connect over HTTPS and control files, shell, git, and more — securely, with zero Python dependencies.
上次检查时间：2026-10-27。 Turn any Linux server into an AI-agent-accessible machine via MCP. ChatGPT, Claude, and Grok connect over HTTPS and control files, shell, git, and more — securely, with zero Python dependencies.
