mpc-bridge

ConfigureCreateconfig.yamlwith your MCP server settings:

bridge: port: 8080 allowed_origins: - http://localhost:3000 servers: git: name: "git" binary: "npx" args: - "-y" - "@modelcontextprotocol/server-git"

# Health check curl http://localhost:8080/health # Send initialize request curl -X POST http://localhost:8080/mcp/git \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{...}}' # Check metrics curl http://localhost:8080/metrics # View debug stream curl http://localhost:8080/debug/stream

GET /mcp/{namespace} → Start SSE stream POST /mcp/{namespace}/message → Send JSON-RPC request

curl -X POST http://localhost:8080/mcp/test/message \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{...}}'

GET /health → Bridge health GET /health/{namespace} → Namespace health

GET /debug → Debug dashboard (HTML) GET /debug/stream → Debug message stream (SSE)

go-mcp-bridge/ ├── cmd/ │ ├── bridge/main.go # Main entry point │ ├── test-server/ # Go test MCP server │ └── test-mcp-server/ # TypeScript test MCP server ├── internal/ │ ├── config/ │ │ └── loader.go # YAML config parser │ ├── mcp/ │ │ ├── handler.go # Protocol handler │ │ ├── jsonrpc.go # JSON-RPC 2.0 │ │ └── types.go # MCP types │ ├── process/ │ │ └── manager.go # Subprocess manager │ ├── router/ │ │ └── namespace.go # Namespace routing │ └── server/ │ ├── http.go # HTTP server │ ├── sse.go # SSE writer │ └── metrics.go # Prometheus metrics ├── docs/ # Documentation │ ├── CONFIG.md # Configuration reference │ ├── API.md # API specification │ ├── EXAMPLES.md # Usage examples │ ├── DEBUG.md # Debug endpoint guide │ └── TESTING.md # Testing guide ├── testdata/ # Test configurations ├── bin/ # Built binaries ├── config.yaml # Configuration ├── Makefile # Build automation ├── test-tool-metrics.sh # Tool metrics test script └── README.md # This file

# Run all unit tests go test ./... -v # Specific package go test ./internal/mcp/... -v

# Start bridge in background ./bin/bridge --config config.yaml & BRIDGE_PID=$! # Run tests ./test.sh # Stop bridge kill $BRIDGE_PID

# Test with real subprocess ./test-tool-metrics.sh # Or run all tests go test ./... -v

- master- Current stable (All phases 1-6 complete)

✅ Phase 1-2: Core Architecture (COMPLETE)

- ✅ HTTP streaming server
- ✅ Subprocess management
- ✅ Basic JSON-RPC handling

✅ Phase 3: MCP Protocol Support (COMPLETE)

- ✅ JSON-RPC 2.0 handling
- ✅ Initialize method
- ✅ Tools/list and tools/call
- ✅ Request-response correlation

✅ Phase 4: Security & Error Handling (COMPLETE)

- ✅ Input validation (JSON-RPC, arguments)
- ✅ Command injection prevention
- ✅ Resource limits (size, connections)
- ✅ Exponential backoff restarts
- ✅ Graceful shutdown
- ✅ Structured JSON logging

✅ Phase 5: Testing & Documentation (COMPLETE)

- ✅ Unit tests (45 tests)

- JSON-RPC parsing (20 tests)
- Config loading (14 tests)
- Namespace routing (11 tests)

- HTTP server tests (20+ tests)
- Process manager tests (15+ tests)
- Namespace isolation tests (10 tests)

✅ Phase 6: Build & Monitoring (COMPLETE)

- ✅ 6.1 Prometheus metrics (/metrics endpoint)

- ✅ HTTP request metrics (mcp_http_requests_total, mcp_http_request_duration_seconds)
- ✅ Active sessions gauge (mcp_active_sessions)
- ✅ Subprocess state metrics (mcp_subprocess_state)
- ✅ Tool call metrics (mcp_tool_calls_total, mcp_tool_calls_duration_seconds, mcp_tool_errors_total)
- ✅ Metrics endpoint at /metrics

- ✅ Replace fmt.Printf with slog
- ✅ JSON structured logging
- ✅ Context-aware logs (namespace, session, request_id)

- ✅ Stream DEBUG and INFO logs to /debug/stream
- ✅ JSON-RPC 2.0 compliant SSE format
- ✅ No verbose flag needed

- ✅ Remove unused debug_port configuration
- ✅ Keep debug endpoints on main port 8080

All phases complete as of Phase 6 merge to master.

- Compatible with StreamableHTTP transport
- Works with latest llama.cpp build

- Uses standard JSON-RPC 2.0 format
- Supports MCP protocol versions:

- 2025-06-18 (latest)
- 2025-03-26 (default)
- 2024-11-05 (backward compat)

These servers can be used with the bridge:

- Check binary path is correct:which npx
- Verify binary is executable:chmod +x ./bin/test-server
- Check environment variables in config
- Look at structured logs for errors

- Verify namespace exists in config
- Checkallowed_originsincludes client origin
- Look at/debug/streamfor real-time errors
- Check/health/{namespace}for subprocess status

- Ensure subprocess outputs JSON-RPC to stdout
- Check for newline termination on messages (\n)
- Verify SSE headers are set correctly
- Use/debug/streamto see raw messages

- Check subprocess logs for errors
- Increase timeout if subprocess is slow
- Verify args are correct
- Check resource limits

- Verify argument sanitization
- Check allowed hosts/origins
- Ensure binary path is safe (no shell injection)
- Create a feature branch
- Add tests for new functionality
- Update documentation
- Submit a pull request

AgentChatBus is a persistent AI communication bus that lets multiple independent AI Agents chat, collaborate, and delegate tasks — across terminals, across IDEs, and across frameworks.

An agentic communication framework for multi-agent collaboration using MCP.

Interact with any other SaaS applications on behalf of your customers.

1001SMS MCP Server helps developers give AI agents access to temporary phone numbers for account registrations, OTP verifications, SMS code receiving, and automated signup workflows. Easy integration for MCP-compatible tools and custom agents.

An MCP server client for the Agent-to-Agent (A2A) protocol, enabling LLMs to interact with A2A agents.

A bridge server connecting Model Context Protocol (MCP) with Agent-to-Agent (A2A) protocol.

A bridge server connecting Model Context Protocol (MCP) with Agent-to-Agent (A2A) protocol.

Production-grade multi-agent communication MCP server with 58 tools over MCP+SSE — real-time messaging, task scheduling, shared memory, and a trust-based evolution engine. SQLite WAL persistence, 4-level RBAC, zero-dependency Python/TypeScript SDKs.

Enables room-based messaging between multiple agents.