Reasons for Google Antigravity MCP call failure and temporary solutions

[oy3o]

Problem

The initial configuration using nc to bridge the MCP stdio transport to the CogServer's TCP port (18888) failed with invalid request errors.
This was caused by two issues:

1. Buffering: Standard nc or shell pipes can buffer input/output, breaking the strict line-based JSON-RPC expectation of the CogServer.
2. Protocol Violation: The CogServer sends a non-compliant {"jsonrpc":"2.0","result":{}} response to the initialized notification (which should not have a response). This caused strict MCP clients to reject the connection.

Temporary Solution

We created a custom Python adapter script to replace nc.

stdio_tcp_client.py

#!/usr/bin/env python3
import socket
import sys
import threading
import argparse
import time

BUFFER_SIZE = 65536
# LOG_FILE = "/tmp/mcp_debug.log"

# def log(msg):
#     with open(LOG_FILE, "a") as f:
#         timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
#         f.write(f"[{timestamp}] {msg}\n")


def stdin_to_socket(sock):
    """Reads from stdin and writes to the socket."""
    # log("Starting stdin_to_socket thread")
    try:
        while True:
            # Read from stdin
            try:
                # Use read1 to get available bytes immediately
                chunk = sys.stdin.buffer.read1(4096)
            except AttributeError:
                chunk = sys.stdin.buffer.read(4096)

            if not chunk:
                # log("Stdin EOF received")
                break

            # log(f"Stdin -> Socket ({len(chunk)} bytes): {chunk}")
            try:
                sock.sendall(chunk)
            except Exception as e:
                # log(f"Socket send error: {e}")
                break

    except Exception as e:
        pass  # log(f"Stdin loop error: {e}")
    finally:
        # log("Shutting down socket WR")
        try:
            sock.shutdown(socket.SHUT_WR)
        except:
            pass


def socket_to_stdout(sock):
    """Reads from the socket and writes to stdout, filtering bad protocol messages."""
    # log("Starting socket_to_stdout thread")
    buffer = b""
    try:
        while True:
            data = sock.recv(BUFFER_SIZE)
            if not data:
                # log("Socket EOF received")
                break

            # log(f"Socket -> Buffer ({len(data)} bytes): {data}")
            buffer += data

            while b"\n" in buffer:
                line_end = buffer.find(b"\n") + 1
                line = buffer[:line_end]
                buffer = buffer[line_end:]

                # Check for the specific malformed response to 'notifications/initialized'
                # CogServer sends: {"jsonrpc":"2.0","result":{}}
                # This response has no 'id', which violates JSON-RPC 2.0 for a Response object,
                # and it shouldn't exist because 'initialized' is a Notification.
                if b'"result":{}' in line and b'"id"' not in line:
                    # log(f"DROPPING MALFORMED LINE: {line}")
                    continue

                # log(f"Forwarding Line: {line}")
                sys.stdout.buffer.write(line)
                sys.stdout.buffer.flush()

    except Exception as e:
        sys.stderr.write(f"Socket loop error: {e}\n")


def main():
    parser = argparse.ArgumentParser(description="Bridge Stdio to TCP for MCP")
    parser.add_argument("host", help="Hostname", nargs="?", default="localhost")
    parser.add_argument("port", help="Port", type=int, nargs="?", default=18888)
    args = parser.parse_args()

    # log(f"=== Starting Session connecting to {args.host}:{args.port} ===")

    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect((args.host, args.port))
        # log("Socket connected successfully")
    except Exception as e:
        # log(f"Failed to connect: {e}")
        sys.stderr.write(f"Failed to connect: {e}\n")
        sys.exit(1)

    t = threading.Thread(target=socket_to_stdout, args=(sock,), daemon=True)
    t.start()

    stdin_to_socket(sock)

    t.join(timeout=2.0)
    # log("=== Session Ended ===")


if __name__ == "__main__":
    main()

Key Features:

• Unbuffered I/O: Reads directly from sys.stdin.buffer and flushes sys.stdout.buffer immediately after every message.
• Protocol Filtering: Intercepts and drops the malformed {"jsonrpc":"2.0","result":{}} message from CogServer, preventing client errors.
• Robustness: Handles socket closures and thread synchronization cleanly.

Configuration

The mcp_config.json was updated to use this adapter:

{
  "mcpServers": {
    "atomese": {
      "command": "path/to/cogserver/examples/mcp/stdio_tcp_client.py",
      "args": [
        "localhost",
        "18888"
      ],
      "env": {}
    }
  }
}

Verification

• Connectivity: Verified via manual nc tests and the Python script.
• Functionality: Successfully executed atomese/version and atomese/echo tools.
• Result:
  • CogServer Version: 5.2.0
  • Echo Test: Passed

While temporary solutions exist, modifying the server to satisfy more demanding clients might be a better option.

[linas]

Many months ago, I started a named pipe ("stdio") interface, but didn't bother to continue, because there didn't seem to be any point to it. According to google, http should work:

{
  "mcpServers": {
    "cogserver": {
      "url": "http://127.0.0.1:18080/mcp"
    }
  }
}

Does this work?

[linas]

FYI, the unix-domain socket version is here: c8c89eb It is untested. I think it compiles, and maybe it works.

[oy3o]

{
  "mcpServers": {
    "cogserver": {
      "url": "http://127.0.0.1:18080/mcp"
    }
  }
}

Does this work?

I did try this, but Antigravity always failed to load the MCP configuration due to timeouts (I suspect there are subtle differences between Antigravity and Claude's MCP configurations), while stdio was more stable and allowed the AI ​​to work properly, although stable prompts and workflow driving may still require continued effort.

[linas]

The only way I know how to debug this is to insert printf's into the code, and examine what was sent and received on the cogserver side. Sometimes I add the print statements myself, sometimes I would have Claude do all the debugging for me. It takes some sweet-talking but it can be done.

Well, I can certainly try Antigravity myself, and see what the problem is ... Or I can ask you to develop a patch.

The patch above creates a named pipe: /var/run/cogserver or something like that. It would need to be wired to stdin/stdout somehow. I really dislike stdin/out as a design point: it is truly horrible, for many reasons: For example, the CogServerNode is usually started inside some other process. It can also be saved/restored in StorageNodes, or otherwise manipulated as a Atom, so thinking of it as a "process" is awkward. It's mutable, movable, controllable. It responds to external start and stop messages.

Not to get too abstract for you, but I'm wondering if the correct solution is to use the "sensory" framework (see https://github.com/opencog/sensory ) and create an StdioNode, and route everything through that. (There are already examples of FileNode, TerminalNode and IRCNode to work from; I would have to think hard about the right design.)

The fast, quick short-term solution is to just debug the http connection.