# Grep-MCP stdio vs SSE Transport Modes: Key Differences Explained

> Explore the key differences between grep-mcp's stdio and SSE transport modes. Understand how stdio uses local pipes and SSE enables remote HTTP connections. Learn more.

- Repository: [gal peretz/grep-mcp](https://github.com/galprz/grep-mcp)
- Tags: deep-dive
- Published: 2026-02-16

---

**Grep-MCP supports stdio for local pipe-based communication and SSE for HTTP-based remote connections, with the key difference being that stdio operates via standard input/output streams while SSE exposes a web server endpoint using Starlette and uvicorn.**

The grep-mcp repository implements the Model Context Protocol (MCP) server with dual transport capabilities, allowing developers to choose between local process communication or network-accessible HTTP streaming. Understanding these grep-mcp stdio and SSE transport modes is essential for selecting the appropriate deployment strategy for your MCP client integration.

## Communication Architecture

The transport layer determines how MCP messages flow between client and server, with fundamentally different implementations for each mode.

### stdio Transport Implementation

In [`src/grep_mcp/server.py`](https://github.com/galprz/grep-mcp/blob/main/src/grep_mcp/server.py), the stdio transport invokes `FastMCP.run(transport='stdio')` (lines 21-24), which hooks the MCP server directly into the process's standard streams. Messages travel as raw JSON-RPC lines read from `sys.stdin` and written to `sys.stdout`, creating a simple pipe-based communication channel without network overhead.

### SSE Transport Implementation

The SSE transport instantiates `SseServerTransport` with a base path of `/messages/` (line 75) and constructs an async Starlette application via `create_starlette_app()`. This exposes two critical endpoints: `/sse` for establishing Server-Sent Event streams and `/messages/` for receiving client posts (lines 98-104). The implementation runs via `uvicorn.run()` (lines 32-43), converting MCP messages into HTTP-wrapped SSE events.

## Launch Commands and Configuration

Selecting a transport mode requires specific command-line arguments when starting the server.

**stdio mode** requires no additional flags:

```bash
python -m grep_mcp

# or explicitly

python -m grep_mcp --transport stdio

```

**SSE mode** requires network configuration:

```bash
python -m grep_mcp --transport sse --host 0.0.0.0 --port 8080

```

The CLI argument parser validates these choices in [`server.py`](https://github.com/galprz/grep-mcp/blob/main/server.py) (lines 21-24), ensuring only valid transport modes are initialized.

## Network Exposure and Security

The stdio transport operates entirely within the process boundary, never opening network sockets. This makes it ideal for local CLI tools where the client spawns the server as a subprocess and communicates via pipes.

Conversely, the SSE transport opens an HTTP endpoint accessible to any client that can reach the host and port. This enables web-based frontends, remote integrations, and deployment behind reverse proxies, but requires network security considerations such as firewall rules and authentication layers external to the MCP server itself.

## Dependencies and Requirements

The stdio transport depends only on the core `fastmcp` package, requiring no additional web frameworks.

The SSE transport requires **Starlette** and **uvicorn**, both declared in [`pyproject.toml`](https://github.com/galprz/grep-mcp/blob/main/pyproject.toml). These dependencies handle the ASGI server lifecycle and HTTP protocol management necessary for maintaining persistent SSE connections.

## Code Examples

### Running in stdio Mode

Start the server for local process communication:

```python

# Terminal 1: Start server

python -m grep_mcp --transport stdio

# The server now listens on stdin for JSON-RPC requests

# Example client interaction via pipe:

echo '{"jsonrpc": "2.0", "method": "tools/list", "id": 1}' | python -m grep_mcp

```

### Running in SSE Mode

Deploy as a network service:

```bash

# Start the HTTP server

python -m grep_mcp --transport sse --host 127.0.0.1 --port 8080

```

Connect via JavaScript EventSource:

```javascript
const source = new EventSource('http://127.0.0.1:8080/sse');

source.onmessage = (event) => {
  const message = JSON.parse(event.data);
  console.log('MCP message:', message);
};

// Send commands to the server
fetch('http://127.0.0.1:8080/messages/', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'tools/call',
    params: { name: 'grep_query', arguments: { pattern: 'TODO' } },
    id: 2
  })
});

```

## Summary

- **stdio transport** uses `FastMCP.run(transport='stdio')` in [`src/grep_mcp/server.py`](https://github.com/galprz/grep-mcp/blob/main/src/grep_mcp/server.py) to communicate via stdin/stdout pipes, requiring no network stack and only the core `fastmcp` dependency.
- **SSE transport** launches an HTTP server via `uvicorn.run()` with Starlette, exposing `/sse` and `/messages/` endpoints for web-based clients, requiring `starlette` and `uvicorn` dependencies.
- stdio mode suits local CLI integrations and subprocess spawning, while SSE mode enables remote access, browser clients, and reverse proxy deployment.
- Both modes execute identical MCP tool logic (such as `grep_query`); only the message transport layer differs between raw JSON-RPC lines and HTTP-wrapped SSE events.

## Frequently Asked Questions

### What is the default transport mode when running grep-mcp?

The default transport mode is **stdio**. When you execute `python -m grep_mcp` without specifying `--transport`, the server initializes with `FastMCP.run(transport='stdio')` and communicates via standard input and output streams.

### Can I run grep-mcp in SSE mode behind a reverse proxy like Nginx?

Yes, the SSE transport is designed for HTTP deployment and works seamlessly behind reverse proxies. When running with `--transport sse`, the server exposes standard HTTP endpoints (`/sse` and `/messages/`) that can be proxied, load-balanced, or secured using external authentication layers.

### Does switching transport modes change the available MCP tools?

No, the transport mode only affects how messages travel between client and server. Whether using stdio or SSE, the same MCP tools (such as `grep_query`) and capabilities are available because the core `FastMCP` instance and tool registrations remain identical in [`src/grep_mcp/server.py`](https://github.com/galprz/grep-mcp/blob/main/src/grep_mcp/server.py).