Building a Gopher MCP Server: Bringing 1991's Internet to Modern AI

The integration of legacy protocols with modern AI infrastructure reveals fundamental insights about system design philosophy and the evolution of network architectures. The gopher-mcp implementation demonstrates how protocols designed with minimalist principles can provide superior performance characteristics and operational simplicity compared to their contemporary counterparts—lessons that remain highly relevant for modern distributed systems engineering.

Historical Context and Protocol Evolution

The Gopher protocol emerged during a critical period in network protocol development, representing an alternative architectural approach to information distribution that prioritized hierarchical organization over hypertext flexibility. Developed at the University of Minnesota under Mark McCahill’s leadership, Gopher implemented a client-server model that emphasized structured navigation and efficient resource discovery.

During the early 1990s, Gopher achieved significant adoption across academic and research institutions, often surpassing early web implementations in both performance and usability metrics. The protocol’s design philosophy centered on deterministic navigation patterns and minimal protocol overhead—characteristics that proved advantageous for the bandwidth-constrained networks of that era.

Protocol Competition and Market Dynamics

Gopher’s displacement by HTTP/HTML resulted from factors largely orthogonal to technical merit—a pattern frequently observed in technology adoption cycles. The critical factors included:

• Licensing Uncertainty: The University of Minnesota’s ambiguous intellectual property stance created adoption friction among commercial developers
• Media Type Limitations: Gopher’s text-centric design philosophy conflicted with the emerging multimedia requirements of commercial internet applications
• Architectural Philosophy: HTTP’s stateless, document-oriented model provided greater flexibility for dynamic content generation compared to Gopher’s hierarchical structure

The contemporary relevance of Gopher’s design principles becomes apparent when analyzing modern web performance challenges: content bloat, client-side complexity, and attention fragmentation. Gopher’s minimalist approach anticipated many of the performance optimization strategies now considered best practices in modern web development.

Contemporary Gopher Protocol Revival

The recent resurgence of Gopher protocol implementations reflects a broader movement toward minimalist computing and information consumption patterns. This revival demonstrates recognition of several architectural advantages:

• Content-Centric Design: Eliminates the presentation layer complexity that characterizes modern web applications, focusing exclusively on information delivery
• Minimal Protocol Overhead: Achieves near-optimal network utilization through elimination of unnecessary protocol features and metadata
• Implementation Simplicity: The protocol specification’s brevity enables rapid client development and reduces attack surface area
• Cognitive Load Reduction: Structured navigation patterns reduce decision fatigue and improve information consumption efficiency

The Model Context Protocol integration opportunity emerges from these characteristics: AI assistants require access to high-quality, structured information without the noise and complexity that characterizes contemporary web content. Gopher’s design philosophy aligns perfectly with AI information consumption patterns.

Model Context Protocol Integration Architecture

The Model Context Protocol establishes a formal abstraction layer between AI models and external resource systems, implementing capability-based security models that ensure safe resource access without compromising system integrity. This architectural approach addresses the fundamental challenge of enabling AI systems to interact with diverse external resources while maintaining security boundaries and operational predictability.

MCP’s design philosophy emphasizes explicit permission models and resource isolation—principles that align naturally with Gopher’s minimalist approach to information access. The protocol combination enables AI assistants to access curated, high-quality information sources without the security and complexity overhead associated with modern web browsing.

Building the Gopher MCP Server

Protocol Abstraction Layer

The architectural insight driving gopher-mcp development centers on protocol abstraction patterns that enable unified handling of related protocol families. Gopher and Gemini protocols share fundamental interaction models despite implementation differences, suggesting opportunities for abstraction that reduce code duplication while maintaining protocol-specific optimizations:

class GopherClient(TTLCacheMixin[GopherFetchResponse]):
    """Async client for the Gopher protocol."""

    async def fetch(self, url: str) -> GopherFetchResponse:
        parsed = parse_gopher_url(url)
        ...


class GeminiClient(TTLCacheMixin[GeminiFetchResponse]):
    """Async client for the Gemini protocol (TLS, TOFU certificates)."""

    async def fetch(self, url: str) -> GeminiFetchResponse:
        ...

This abstraction demonstrates the Strategy pattern’s effectiveness in protocol handling scenarios. Both clients expose an identical async fetch surface and inherit their caching behavior from a shared TTLCacheMixin, so protocol addition becomes a matter of implementing that same interface rather than core system modification—ensuring system stability while enabling rapid capability expansion, a critical requirement for production systems that must evolve without service interruption.

Gopher Protocol Implementation

The Gopher protocol is refreshingly simple. Here’s how a basic client works:

import asyncio


async def fetch_gopher(
    host: str, port: int, selector: str, *, max_bytes: int, timeout: float
) -> bytes:
    """Send a Gopher request and return the raw response bytes."""

    async def _io() -> bytes:
        reader, writer = await asyncio.open_connection(host, port)
        try:
            # Send Gopher request (just the selector + CRLF)
            writer.write(selector.encode("utf-8") + b"\r\n")
            await writer.drain()

            # Read the response in chunks, enforcing the size cap
            chunks: list[bytes] = []
            total = 0
            while chunk := await reader.read(65536):
                total += len(chunk)
                if total > max_bytes:
                    raise GopherProtocolError(
                        f"Response exceeds maximum size of {max_bytes} bytes"
                    )
                chunks.append(chunk)
            return b"".join(chunks)
        finally:
            writer.close()
            await writer.wait_closed()

    return await asyncio.wait_for(_io(), timeout=timeout)

This exemplifies the protocol’s minimalist design philosophy: request-response semantics without the complexity overhead that characterizes modern web protocols. The absence of status codes, headers, and content negotiation reduces both implementation complexity and network overhead—characteristics that prove advantageous for high-performance, low-latency applications.

Content Type Detection

Gopher uses a simple but effective type system that predates MIME types:

_GOPHER_TYPE_CATEGORY: dict[str, str] = {
    "0": "text",    # Text file
    "1": "menu",    # Directory listing
    "7": "menu",    # Search server
    "9": "binary",  # Binary file
    "g": "binary",  # GIF image
    "I": "binary",  # Image file
    "h": "text",    # HTML document
    # ... more types
}


def gopher_type_category(gopher_type: str) -> str:
    """Return the handling category for a Gopher item type.

    One of "menu", "text", "binary" or "interactive". Unknown
    types default to "text", matching historical behaviour.
    """
    return _GOPHER_TYPE_CATEGORY.get(gopher_type, "text")

Practical Applications

Research and Documentation

One of the most compelling use cases I’ve discovered is research. Gopher servers often host high-quality, curated content:

• Academic papers: Many universities maintain Gopher archives
• Technical documentation: Clean, distraction-free technical docs
• Historical archives: Digital libraries and historical collections

When your AI assistant can browse these resources, it’s accessing information that’s often more reliable and better curated than random web pages.

Development Workflows

Here’s a practical example of how I use the Gopher MCP server in my development workflow:

# AI assistant browsing Gopher for technical documentation
> Browse gopher://gopher.floodgap.com/1/world for information about protocol specifications

# AI assistant accessing university research archives
> Search gopher://gopher.umn.edu/ for papers on distributed systems

# AI assistant exploring historical computing resources
> Navigate to gopher://sdf.org/1/users/cat/gopher-history for protocol history

The AI gets clean, focused content without the noise of modern web advertising and tracking.

Architecture Patterns for Protocol Servers

Resource-Centric Design

Building a protocol MCP server taught me the importance of separating concerns:

class MenuResult(BaseModel):
    kind: Literal["menu"] = "menu"
    items: list[GopherMenuItem]
    truncated: bool = False
    request_info: dict[str, Any]


class BinaryResult(BaseModel):
    kind: Literal["binary"] = "binary"
    bytes: int
    mime_type: str | None
    note: str  # binary payloads are described, not returned
    request_info: dict[str, Any]


GopherFetchResponse = MenuResult | TextResult | BinaryResult | ErrorResult

This pattern lets you swap out protocol implementations without touching the MCP logic. Want to add support for Finger protocol? Define its result models and a client that returns them—the MCP layer just serializes whichever result comes back.

Async-First Architecture

Protocol servers need to handle multiple concurrent requests efficiently:

class GopherClient(TTLCacheMixin[GopherFetchResponse]):
    async def fetch(self, url: str) -> GopherFetchResponse:
        parsed = parse_gopher_url(url)
        self._validate_security(parsed)

        # Check cache first (TTL expiry, LRU touch)
        if self.cache_enabled:
            cached = self._get_cached_response(url)
            if cached is not None:
                return cached

        # Fetch, bounded by an asyncio.Semaphore when a
        # concurrency cap is configured
        response = await self._bounded_fetch(parsed)

        # Cache non-error responses; the mixin evicts the least
        # recently used entry once max_cache_entries is reached
        if self.cache_enabled and not isinstance(response, ErrorResult):
            self._cache_response(url, response)

        return response

Because everything runs on a single asyncio event loop, the cache itself is just an OrderedDict with TTL timestamps—no locks required. Concurrency is bounded where it matters: at the sockets.

Best Practices for Protocol MCP Servers

Error Handling

Implement comprehensive error handling with context:

class GopherProtocolError(Exception):
    """Raised when a Gopher request cannot be completed."""


class SSRFError(ValueError):
    """Raised when a target host/address is blocked by the SSRF policy."""


class ErrorResult(BaseModel):
    kind: Literal["error"] = "error"
    error: dict[str, str]
    request_info: dict[str, Any]

The client catches SSRFError, GopherProtocolError, and unexpected exceptions at the fetch boundary and converts them into an ErrorResult, so failures surface as structured data the model can reason about rather than an unhandled exception.

Configuration Management

Keep configuration simple but flexible:

from pydantic_settings import BaseSettings, SettingsConfigDict


class GopherConfig(BaseSettings):
    """Gopher client settings, read from GOPHER_* environment variables."""

    model_config = SettingsConfigDict(env_prefix="GOPHER_")

    max_response_size: int = 1024 * 1024  # 1MB
    timeout_seconds: float = 30.0
    cache_ttl_seconds: int = 300  # 5 minutes
    max_cache_entries: int = 1000
    allow_local_hosts: bool = False  # SSRF guard stays on by default

The Future of Alternative Protocols in AI

Building the Gopher MCP server opened my eyes to something interesting: there’s a whole ecosystem of alternative protocols that could benefit AI assistants:

• Gemini: Gopher’s modern successor with TLS and markdown support
• Finger: Simple user information protocol
• NNTP: Network News Transfer Protocol for accessing Usenet
• IRC: Real-time chat protocol integration

Each of these protocols represents a different approach to information sharing, and each could provide unique value to AI assistants.

Architectural Insights and Design Principles

The gopher-mcp implementation reveals fundamental insights about the relationship between protocol complexity and system reliability. Gopher’s design philosophy—prioritizing content delivery over presentation flexibility—aligns naturally with AI information consumption patterns, where structured data access takes precedence over multimedia presentation.

The protocol’s architectural simplicity provides an ideal foundation for understanding MCP server design patterns. The minimal complexity overhead enables focus on core architectural concerns—resource management, caching strategies, and error handling—without the distraction of protocol-specific edge cases that characterize more complex implementations.

Getting Started

Want to try the Gopher MCP server yourself? Here’s how to get started:

# Run the server directly with uv
uvx gopher-mcp

# Or install it with pip
pip install gopher-mcp

# Configure your AI assistant to use it
# (specific steps depend on your MCP client)

# Start exploring Gopher space
# Try gopher://gopher.floodgap.com/ for a good starting point

The Gopher internet is small but surprisingly rich. You’ll find everything from technical documentation to poetry, all presented in that clean, distraction-free format that makes information consumption a pleasure rather than a chore.

---

Interested in exploring more? Visit the project documentation or check out the GitHub repository for complete implementation details and examples.