What is the difference between remote and local MCP servers?

Remote MCP servers expose HTTP endpoints accessible over the network, allowing live status checks. Local MCP servers are installed as packages (npm, PyPI, OCI) and run locally without network endpoints, so their status is unknown to indexes.

Can Wellknown check the status of local MCP servers?

No. Local MCP servers have no network endpoint to check, so Wellknown's observed status for them is always unknown. This means no live monitoring is possible for local packages.

Which endpoint types correspond to remote MCP servers?

Remote MCP servers mainly use the endpoint types mcp_streamable_http (31,387 records) and mcp_sse (1,034 records), both of which are accessible over HTTP and can be checked live over the network.

What does an unknown status mean for an MCP server?

Unknown status means there is nothing to check or no check has run, which is typical for local package-installed MCP servers. It does not imply failure or that the server is broken.

How many MCP servers are local packages versus remote endpoints?

There are 27,171 npm packages, 20,180 PyPI packages, and 1,193 OCI container images as local MCP servers. Remote MCP servers with HTTP endpoints number 31,387 for Streamable HTTP and 1,034 for SSE, totaling 39,544 network-checkable endpoints.

Remote vs Local MCP Servers: Key Differences and Network Checkability

Learn the differences between remote and local MCP servers, their endpoint types, network checkability, and implications for choosing an MCP server.

Published: November 1, 2026Data as of: November 1, 2026

Remote and local MCP servers differ primarily in how they are accessed and checked for availability. Remote MCP servers use HTTP endpoints (mcp_* types) and can be checked over the network, while local MCP servers are installed from package registries (package_* types) and have no network endpoint to check, resulting in an unknown observed status. This distinction affects how indexes like Wellknown monitor server status and reliability.

Key takeaways

Local MCP servers are installed as packages (npm, PyPI, OCI) and have no network endpoint, so their status is always unknown.
Remote MCP servers expose HTTP endpoints (Streamable HTTP, SSE) that can be checked live over the network.
Wellknown can only perform network checks on remote MCP servers, not on local package-installed servers.
Choosing between remote and local MCP servers involves trade-offs in observability and monitoring.
The majority of MCP servers indexed are remote HTTP endpoints, but local packages form a significant portion.

What are local MCP servers?

Local MCP servers are programs installed from package registries or container images that implement the Model Context Protocol (MCP). They are not accessed over the network but run locally in the developer's environment. According to the endpoint types in Wellknown's index:

package_npm: 27,171 records — a local server installed as an npm package.
package_pypi: 20,180 records — a local server installed as a PyPI package.
package_oci: 1,193 records — a local server run from an OCI container image.

These local servers have no network endpoint exposed for remote checking. As per Wellknown's termRules, this means their observed status is always unknown because there is nothing to check or no check has run. This is the ordinary case for packages.

What are remote MCP servers?

Remote MCP servers expose their functionality over HTTP endpoints that an AI application or index can reach over the network. The main remote endpoint types are:

mcp_streamable_http: 31,387 records — a remote MCP endpoint using Streamable HTTP.
mcp_sse: 1,034 records — a remote MCP endpoint using Server-Sent Events (SSE).

These remote endpoints allow Wellknown and other indexes to perform network checks to observe their status, latency, and reliability. The observed statuses for these can be live, recently observed, or unavailable depending on the success of recent checks.

Network checkability: what can be monitored?

Wellknown's index records 39,544 network-checkable endpoints, which correspond to remote MCP servers exposing HTTP endpoints. These endpoints can be probed to determine if the server is live or unavailable.

In contrast, local MCP servers installed from packages have no network endpoint to check. Their status is always unknown, which means:

The index cannot verify if the server is currently running or reachable.
Unknown status does not imply failure or brokenness; it simply means no network check is possible.

This distinction is important for developers relying on indexes for server reliability information.

Implications when choosing an MCP server

When selecting an MCP server, understanding the difference between remote and local servers helps in managing monitoring and reliability expectations:

Local MCP servers (package_npm, package_pypi, package_oci):
- Installed and run locally.
- No network endpoint means no live status monitoring by indexes.
- Suitable when local control and integration are priorities.
Remote MCP servers (mcp_streamable_http, mcp_sse):
- Accessible over HTTP.
- Can be monitored live for uptime and latency.
- Useful when remote availability and observability are required.

Developers should consider whether they need live status monitoring and network observability when choosing between local and remote MCP servers.

Summary of endpoint types and counts

Endpoint Type	Count	Description	Network Checkable
package_npm	27,171	Local server installed as an npm package	No
package_pypi	20,180	Local server installed as a PyPI package	No
package_oci	1,193	Local server run from an OCI container	No
mcp_streamable_http	31,387	Remote MCP endpoint using Streamable HTTP	Yes
mcp_sse	1,034	Remote MCP endpoint using SSE	Yes

Observed status distribution

Total MCP servers indexed: 76,105
Live MCP servers (observed): 23,110
Unknown status MCP servers (mostly local packages): 45,990

This shows a large portion of MCP servers are local packages with unknown status due to lack of network endpoints.

Conclusion

Remote MCP servers expose HTTP endpoints that indexes like Wellknown can check live over the network, providing real-time status and reliability data. Local MCP servers installed from package registries do not expose network endpoints, so their status remains unknown to indexes. When choosing an MCP server, consider whether you need network observability and live status monitoring (favoring remote servers) or prefer local installation and control (favoring local packages).

This data is a snapshot as of 2026-11-01T00:37:39.756Z from Wellknown's live index.