Unable to connect to MCP sever

[dev4Kushal]

Pre-submission Checklist

• I have checked that this question would not be more appropriate as an issue in a specific repository
• I have searched existing discussions and documentation for answers

Question Category

• Protocol Specification
• SDK Usage
• Server Implementation
• General Implementation
• Documentation
• Other

Your Question

Hello everyone,

I’m working on a Python application that primarily handles backend functionality. Recently, I tried to implement an MCP server. The communication between my backend service layer and the MCP server is set up through a client using stdio.

However, when I try to call the API, the client is unable to reach the MCP server. I’ve tried several approaches, but since I’m new to MCP servers, I’m struggling to get this communication working.

Could anyone guide me on how to properly establish communication between the client and the MCP server with stdio?

[Tengen-12]

When using stdio for MCP communication, both the client and server must exchange newline-delimited JSON-RPC 2.0 messages over standard input/output (not HTTP).

Checklist:
Your MCP server should read from stdin, respond via stdout, and always flush() after printing.
Avoid logs on stdout use stderr instead.
Keep the server running; don’t exit after one request.
Each message must end with a newline (\n).
Test your server using the MCP Inspector if it works there, the issue is in how your client launches the subprocess.

for example
import sys, json
for line in sys.stdin:
req = json.loads(line)
res = {"jsonrpc": "2.0", "id": req.get("id"), "result": {"msg": "Hello MCP!"}}
print(json.dumps(res), flush=True)

ensure flushing, proper newline separation, and correct working directory when spawning the subprocess.

[isheng-eqi]

stdio MCP connections fail for a small set of predictable reasons. Let me give you a systematic debugging checklist.

The stdio contract

MCP over stdio uses newline-delimited JSON-RPC 2.0:

• Server reads from stdin, writes responses to stdout
• Each message is a single JSON object followed by \n
• Everything else (logs, debug output, print statements) MUST go to stderr
• The server must stay alive — it is a persistent process, not a one-shot script

Debugging checklist

Run through these in order.

1. Verify your server works standalone

First, test the server independently — send a raw JSON-RPC initialize message to it:

echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' | python your_server.py

If you get a valid JSON-RPC response on stdout, the server works. If you get nothing or garbled output, the server has a bug.

2. Check stdout vs stderr pollution

The most common failure: print() statements in your server code going to stdout.

# WRONG — this goes to stdout and breaks the JSON-RPC stream
print("Server started on port 8000")

# RIGHT — use stderr for all logging
import sys
print("Server started on port 8000", file=sys.stderr)

# Or use Python logging configured to stderr
import logging
logging.basicConfig(stream=sys.stderr, level=logging.INFO)

Even a single print("hello") on stdout will corrupt the JSON-RPC message stream. Check every print in your server code.

3. Verify your client spawns the process correctly

The client must launch the server as a child process with stdin/stdout piped:

import subprocess
import json

proc = subprocess.Popen(
    ["python", "your_server.py"],
    stdin=subprocess.PIPE,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,  # important: capture stderr separately
    text=True
)

# Send initialize request
request = json.dumps({
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
        "protocolVersion": "2024-11-05",
        "capabilities": {},
        "clientInfo": {"name": "my-client", "version": "1.0"}
    }
})

proc.stdin.write(request + "\n")
proc.stdin.flush()

# Read response
response_line = proc.stdout.readline()
response = json.loads(response_line)
print(response)

Common mistakes in client code:

• Not adding \n after the JSON message
• Not calling flush() after writing
• Using proc.communicate() which closes stdin after one message
• Expecting HTTP-style responses (MCP is raw JSON-RPC, not HTTP)

4. Check working directory

If your server loads config files or modules using relative paths, the working directory matters. Set it explicitly:

proc = subprocess.Popen(
    ["python", "your_server.py"],
    stdin=subprocess.PIPE,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    text=True,
    cwd="/path/to/your/project"  # ← explicit working directory
)

5. Test with MCP Inspector

The MCP Inspector is the standard debugging tool. If your server works in the Inspector, the problem is in your client code, not the server:

npx @modelcontextprotocol/inspector python your_server.py

This connects to your server via stdio and provides a web UI to test tools, resources, and prompts.

6. The "API call fails but Inspector works" pattern

If MCP Inspector works but your backend-to-MCP call fails, the issue is almost certainly in how your backend launches the subprocess. Common causes:

• Backend framework conflicts: FastAPI/Flask run in event loops that may conflict with subprocess management
• Premature stdin close: If you use proc.communicate(input=...), stdin closes after the first message, killing the server
• Buffering: Python's output buffering when not connected to a TTY — add PYTHONUNBUFFERED=1 to the server's environment

proc = subprocess.Popen(
    ["python", "-u", "your_server.py"],  # -u flag for unbuffered output
    env={**os.environ, "PYTHONUNBUFFERED": "1"},
    ...
)

Quick test script

Save this as test_mcp_client.py and run it:

import subprocess, json, sys

proc = subprocess.Popen(
    [sys.executable, "your_server.py"],
    stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
    text=True, env={**__import__("os").environ, "PYTHONUNBUFFERED": "1"}
)

# Initialize
msg = {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}
proc.stdin.write(json.dumps(msg) + "\n")
proc.stdin.flush()
resp = proc.stdout.readline()
print("Init response:", resp.strip())

# List tools
msg2 = {"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}
proc.stdin.write(json.dumps(msg2) + "\n")
proc.stdin.flush()
resp2 = proc.stdout.readline()
print("Tools:", resp2.strip())

# Check stderr for server logs
stderr_output = proc.stderr.read()
if stderr_output:
    print("Server logs:\n", stderr_output)

proc.terminate()

If this works, your server is fine — the problem is in how your backend service launches the subprocess.